diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 5bfb64e36d8..abf77daf0d4 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -271,6 +271,7 @@ apache-lucene-grouping = { module = "org.apache.lucene:lucene-grouping", version apache-lucene-highlighter = { module = "org.apache.lucene:lucene-highlighter", version.ref = "apache-lucene" } apache-lucene-join = { module = "org.apache.lucene:lucene-join", version.ref = "apache-lucene" } apache-lucene-misc = { module = "org.apache.lucene:lucene-misc", version.ref = "apache-lucene" } +apache-lucene-monitor = { module = "org.apache.lucene:lucene-monitor", version.ref = "apache-lucene" } apache-lucene-queries = { module = "org.apache.lucene:lucene-queries", version.ref = "apache-lucene" } apache-lucene-queryparser = { module = "org.apache.lucene:lucene-queryparser", version.ref = "apache-lucene" } apache-lucene-spatialextras = { module = "org.apache.lucene:lucene-spatial-extras", version.ref = "apache-lucene" } diff --git a/settings.gradle b/settings.gradle index 7035b75bfdf..e9344553b6b 100644 --- a/settings.gradle +++ b/settings.gradle @@ -56,6 +56,7 @@ include "solr:modules:ltr" include "solr:modules:s3-repository" include "solr:modules:scripting" include "solr:modules:sql" +include "solr:modules:saved-search" include "solr:webapp" include "solr:benchmark" include "solr:test-framework" diff --git a/solr/core/src/java/org/apache/solr/core/SolrResourceLoader.java b/solr/core/src/java/org/apache/solr/core/SolrResourceLoader.java index 11f61a12ae2..64c026ea79b 100644 --- a/solr/core/src/java/org/apache/solr/core/SolrResourceLoader.java +++ b/solr/core/src/java/org/apache/solr/core/SolrResourceLoader.java @@ -112,7 +112,11 @@ public class SolrResourceLoader "hdfs.", "hdfs.update.", "crossdc.handler.", - "crossdc.update.processor." + "crossdc.update.processor.", + "savedsearch.", + "savedsearch.cache.", + "savedsearch.search.", + "savedsearch.update." }; private static final Charset UTF_8 = StandardCharsets.UTF_8; public static final String SOLR_ALLOW_UNSAFE_RESOURCELOADING_PARAM = diff --git a/solr/core/src/java/org/apache/solr/handler/component/DebugComponent.java b/solr/core/src/java/org/apache/solr/handler/component/DebugComponent.java index 0adcdb93b1f..71c08e212a1 100644 --- a/solr/core/src/java/org/apache/solr/handler/component/DebugComponent.java +++ b/solr/core/src/java/org/apache/solr/handler/component/DebugComponent.java @@ -116,6 +116,14 @@ public void process(ResponseBuilder rb) throws IOException { info.add("facet-debug", fdebug.getFacetDebugInfo()); } + CustomDebugInfoSources customDebugInfoSources = + (CustomDebugInfoSources) rb.req.getContext().get(CustomDebugInfoSources.KEY); + if (customDebugInfoSources != null) { + for (var customDebugInfoSource : customDebugInfoSources.list) { + info.add(customDebugInfoSource.name, customDebugInfoSource.values); + } + } + if (rb.req.getJSON() != null) { info.add(JSON, rb.req.getJSON()); } @@ -140,6 +148,28 @@ public void process(ResponseBuilder rb) throws IOException { } } + public static class CustomDebugInfoSources { + + public static final String KEY = "CustomDebugInfoSources"; + + private final List list = new ArrayList<>(); + + public void add(CustomDebugInfoSource source) { + list.add(source); + } + } + + public static class CustomDebugInfoSource { + + private final String name; + private final SimpleOrderedMap values; + + public CustomDebugInfoSource(String name, SimpleOrderedMap values) { + this.name = name; + this.values = values; + } + } + private void doDebugTrack(ResponseBuilder rb) { final String rid = rb.req.getParams().get(CommonParams.REQUEST_ID); rb.addDebug(rid, "track", CommonParams.REQUEST_ID); // to see it in the response diff --git a/solr/licenses/lucene-monitor-9.11.1.jar.sha1 b/solr/licenses/lucene-monitor-9.11.1.jar.sha1 new file mode 100644 index 00000000000..5904d0eb15b --- /dev/null +++ b/solr/licenses/lucene-monitor-9.11.1.jar.sha1 @@ -0,0 +1 @@ +fa731be343ec79d940c7abd0dd8ff1de9bf9c7f1 diff --git a/solr/modules/saved-search/build.gradle b/solr/modules/saved-search/build.gradle new file mode 100644 index 00000000000..32781165e30 --- /dev/null +++ b/solr/modules/saved-search/build.gradle @@ -0,0 +1,34 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +apply plugin: 'java-library' + +description = 'Apache Solr Monitor' + +dependencies { + + implementation project(":solr:core") + implementation project(":solr:solrj") + implementation libs.apache.lucene.core + implementation libs.apache.lucene.monitor + implementation libs.benmanes.caffeine + implementation libs.dropwizard.metrics.core + testImplementation project(':solr:test-framework') + testImplementation libs.junit.junit +} + + diff --git a/solr/modules/saved-search/src/java/org/apache/lucene/monitor/CandidateMatcher.java b/solr/modules/saved-search/src/java/org/apache/lucene/monitor/CandidateMatcher.java new file mode 100644 index 00000000000..055f1b07c87 --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/lucene/monitor/CandidateMatcher.java @@ -0,0 +1,125 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.lucene.monitor; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.TimeUnit; +import org.apache.lucene.search.IndexSearcher; +import org.apache.lucene.search.Query; + +/** Class used to match candidate queries selected by a Presearcher from a Monitor query index. */ +public abstract class CandidateMatcher { + + /** The searcher to run candidate queries against */ + protected final IndexSearcher searcher; + + private final Map errors = new HashMap<>(); + private final List> matches; + + private long searchTime = System.nanoTime(); + + private static class MatchHolder { + Map matches = new HashMap<>(); + } + + /** + * Creates a new CandidateMatcher for the supplied DocumentBatch + * + * @param searcher the IndexSearcher to run queries against + */ + public CandidateMatcher(IndexSearcher searcher) { + this.searcher = searcher; + int docCount = searcher.getIndexReader().maxDoc(); + this.matches = new ArrayList<>(docCount); + for (int i = 0; i < docCount; i++) { + this.matches.add(new MatchHolder<>()); + } + } + + /** + * Runs the supplied query against this CandidateMatcher's set of documents, storing any resulting + * match, and recording the query in the presearcher hits + * + * @param queryId the query id + * @param matchQuery the query to run + * @param metadata the query metadata + * @throws IOException on IO errors + */ + public abstract void matchQuery(String queryId, Query matchQuery, Map metadata) + throws IOException; + + /** + * Record a match + * + * @param match a QueryMatch object + */ + protected final void addMatch(T match, int doc) { + MatchHolder docMatches = matches.get(doc); + docMatches.matches.compute( + match.getQueryId(), + (key, oldValue) -> { + if (oldValue != null) { + return resolve(match, oldValue); + } + return match; + }); + } + + /** + * If two matches from the same query are found (for example, two branches of a disjunction), + * combine them. + * + * @param match1 the first match found + * @param match2 the second match found + * @return a Match object that combines the two + */ + public abstract T resolve(T match1, T match2); + + /** Called by the Monitor if running a query throws an Exception */ + public void reportError(String queryId, Exception e) { + this.errors.put(queryId, e); + } + + /** + * @return the matches from this matcher + */ + public final MultiMatchingQueries finish(long buildTime, int queryCount) { + doFinish(); + this.searchTime = + TimeUnit.MILLISECONDS.convert(System.nanoTime() - searchTime, TimeUnit.NANOSECONDS); + List> results = new ArrayList<>(); + for (MatchHolder matchHolder : matches) { + results.add(matchHolder.matches); + } + return new MultiMatchingQueries<>( + results, errors, buildTime, searchTime, queryCount, matches.size()); + } + + /** Called when all monitoring of a batch of documents is complete */ + protected void doFinish() {} + + /** Copy all matches from another CandidateMatcher */ + protected void copyMatches(CandidateMatcher other) { + this.matches.clear(); + this.matches.addAll(other.matches); + } +} diff --git a/solr/modules/saved-search/src/java/org/apache/lucene/monitor/Visitors.java b/solr/modules/saved-search/src/java/org/apache/lucene/monitor/Visitors.java new file mode 100644 index 00000000000..b21abfdc027 --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/lucene/monitor/Visitors.java @@ -0,0 +1,136 @@ +/* + * + * * + * * * Licensed to the Apache Software Foundation (ASF) under one or more + * * * contributor license agreements. See the NOTICE file distributed with + * * * this work for additional information regarding copyright ownership. + * * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * * (the "License"); you may not use this file except in compliance with + * * * the License. You may obtain a copy of the License at + * * * + * * * http://www.apache.org/licenses/LICENSE-2.0 + * * * + * * * Unless required by applicable law or agreed to in writing, software + * * * distributed under the License is distributed on an "AS IS" BASIS, + * * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * * See the License for the specific language governing permissions and + * * * limitations under the License. + * * + * + */ + +package org.apache.lucene.monitor; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.function.BiPredicate; +import java.util.function.Supplier; +import java.util.stream.Collectors; +import org.apache.lucene.analysis.Analyzer; +import org.apache.lucene.document.Document; +import org.apache.lucene.index.IndexReader; +import org.apache.lucene.index.LeafReader; +import org.apache.lucene.search.Query; +import org.apache.lucene.util.BytesRef; + +public class Visitors { + + public static class MonitorFields { + public static final String QUERY_ID = QueryIndex.FIELDS.query_id + "_"; + public static final String CACHE_ID = QueryIndex.FIELDS.cache_id + "_"; + public static final String MONITOR_QUERY = QueryIndex.FIELDS.mq + "_"; + + public static final Set REQUIRED_MONITOR_SCHEMA_FIELDS = + Set.of(QUERY_ID, CACHE_ID, MONITOR_QUERY); + } + + public static class DocumentBatchVisitor implements AutoCloseable, Supplier { + + private final DocumentBatch batch; + private final List docs; + + private DocumentBatchVisitor(DocumentBatch batch, List docs) { + this.batch = batch; + this.docs = docs; + } + + public static DocumentBatchVisitor of(Analyzer analyzer, List docs) { + return new DocumentBatchVisitor( + DocumentBatch.of(analyzer, docs.toArray(new Document[0])), docs); + } + + @Override + public void close() throws IOException { + batch.close(); + } + + @Override + public LeafReader get() { + return batch.get(); + } + + public int size() { + return docs.size(); + } + + @Override + public String toString() { + return docs.stream().map(Document::toString).collect(Collectors.joining(" ")); + } + } + + public static class QueryTermFilterVisitor implements BiPredicate { + + private final QueryIndex.QueryTermFilter queryTermFilter; + + public QueryTermFilterVisitor(IndexReader reader) throws IOException { + this.queryTermFilter = new QueryIndex.QueryTermFilter(reader); + } + + @Override + public boolean test(String field, BytesRef bytesRef) { + return queryTermFilter.test(field, bytesRef); + } + } + + public static class QCEVisitor { + + private final QueryCacheEntry qce; + + private QCEVisitor(QueryCacheEntry qce) { + this.qce = qce; + } + + public static List decompose(MonitorQuery mq, QueryDecomposer decomposer) { + List cacheEntries = new ArrayList<>(); + for (var queryCacheEntry : QueryCacheEntry.decompose(mq, decomposer)) { + cacheEntries.add(new QCEVisitor(queryCacheEntry)); + } + return cacheEntries; + } + + public Query getMatchQuery() { + return qce.matchQuery; + } + + public String getCacheId() { + return qce.cacheId; + } + + public String getQueryId() { + return qce.queryId; + } + + public Map getMetadata() { + return qce.metadata; + } + + @Override + public String toString() { + return qce.toString(); + } + } +} diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingPresearcher.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingPresearcher.java new file mode 100644 index 00000000000..ef001a1d7ed --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingPresearcher.java @@ -0,0 +1,176 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.function.BiPredicate; +import org.apache.lucene.document.Document; +import org.apache.lucene.document.Field; +import org.apache.lucene.index.LeafReader; +import org.apache.lucene.monitor.CustomQueryHandler; +import org.apache.lucene.monitor.MultipassTermFilteredPresearcher; +import org.apache.lucene.monitor.Presearcher; +import org.apache.lucene.monitor.TermFilteredPresearcher; +import org.apache.lucene.monitor.TermWeightor; +import org.apache.lucene.search.Query; +import org.apache.lucene.util.BytesRef; + +/** + * The motivation behind this is to map each document field to its corresponding, presearcher-owned + * equivalent. By prefixing we ensure "presearcher fields" don't inadvertently affect the scores of + * "real" document fields. Another issue is that the presearcher can dynamically create field + * configurations for a given field name that might not be compatible with the pre-existing schema + * definition, see {\@link + * org.apache.solr.savedsearch.SingleCoreSavedSearchTest#coexistWithRegularDocumentsTest}. In the + * case of {@link org.apache.lucene.monitor.MultipassTermFilteredPresearcher#field(String, int)}, + * the presearcher is capable of creating new fields by adding an ordinal suffix to an existing + * field name. This could also clash with user-defined name patterns, hence the existence of this + * class, which allows users to alias presearcher fields as they see fit. + */ +public class AliasingPresearcher extends Presearcher { + + private final Presearcher aliasingPresearcher; + private final String prefix; + + AliasingPresearcher(Presearcher aliasingPresearcher, String prefix) { + this.aliasingPresearcher = aliasingPresearcher; + this.prefix = prefix; + } + + @Override + public Query buildQuery(LeafReader reader, BiPredicate termAcceptor) { + BiPredicate aliasingTermAcceptor = + (fieldName, term) -> termAcceptor.test(prefix + fieldName, term); + return aliasingPresearcher.buildQuery(reader, aliasingTermAcceptor); + } + + @Override + public Document indexQuery(Query query, Map metadata) { + var document = aliasingPresearcher.indexQuery(query, metadata); + return alias(document); + } + + public String getPrefix() { + return prefix; + } + + private Document alias(Document in) { + Document out = new Document(); + for (var field : in) { + if (!TermFilteredPresearcher.ANYTOKEN_FIELD.equals(field.name()) + && field instanceof Field + && ((Field) field).tokenStreamValue() != null) { + out.add( + new Field( + prefix + field.name(), ((Field) field).tokenStreamValue(), field.fieldType())); + } else { + out.add(field); + } + } + return out; + } + + public static class MultiPassTermFiltered extends MultipassTermFilteredPresearcher { + + private final String prefix; + + private MultiPassTermFiltered( + int passes, + float minWeight, + TermWeightor weightor, + List queryHandlers, + Set filterFields, + String prefix) { + super(passes, minWeight, weightor, queryHandlers, filterFields); + this.prefix = prefix; + } + + @Override + protected DocumentQueryBuilder getQueryBuilder() { + return new TermFiltered.AliasingDocumentQueryBuilder(super.getQueryBuilder(), prefix); + } + + public static AliasingPresearcher build( + int passes, + float minWeight, + TermWeightor weightor, + List queryHandlers, + Set filterFields, + String prefix) { + return new AliasingPresearcher( + new MultiPassTermFiltered( + passes, minWeight, weightor, queryHandlers, filterFields, prefix), + prefix); + } + } + + public static class TermFiltered extends TermFilteredPresearcher { + + private final String prefix; + + TermFiltered( + TermWeightor weightor, + List customQueryHandlers, + Set filterFields, + String prefix) { + super(weightor, customQueryHandlers, filterFields); + this.prefix = prefix; + } + + public static AliasingPresearcher build( + TermWeightor weightor, + List queryHandlers, + Set filterFields, + String prefix) { + return new AliasingPresearcher( + new TermFiltered(weightor, queryHandlers, filterFields, prefix), prefix); + } + + @Override + protected DocumentQueryBuilder getQueryBuilder() { + return new AliasingDocumentQueryBuilder(super.getQueryBuilder(), prefix); + } + + static class AliasingDocumentQueryBuilder implements DocumentQueryBuilder { + + private final DocumentQueryBuilder documentQueryBuilder; + private final String prefix; + + public AliasingDocumentQueryBuilder( + DocumentQueryBuilder documentQueryBuilder, String prefix) { + this.documentQueryBuilder = documentQueryBuilder; + this.prefix = prefix; + } + + @Override + public void addTerm(String field, BytesRef term) throws IOException { + documentQueryBuilder.addTerm(prefix + field, term); + } + + @Override + public Query build() { + return documentQueryBuilder.build(); + } + } + } +} diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchDataValues.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchDataValues.java new file mode 100644 index 00000000000..d37721f9a42 --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchDataValues.java @@ -0,0 +1,76 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch; + +import java.io.IOException; +import org.apache.lucene.index.LeafReader; +import org.apache.lucene.index.LeafReaderContext; +import org.apache.lucene.index.NumericDocValues; +import org.apache.lucene.index.SortedDocValues; +import org.apache.lucene.monitor.Visitors.MonitorFields; +import org.apache.lucene.search.DocIdSetIterator; +import org.apache.solr.common.params.CommonParams; + +public class SavedSearchDataValues { + + private final SortedDocValues queryIdIt; + private final SortedDocValues cacheIdIt; + private final SortedDocValues mqIt; + private final NumericDocValues versionIt; + private final LeafReader reader; + private int currentDoc; + + public SavedSearchDataValues(LeafReaderContext context) throws IOException { + reader = context.reader(); + cacheIdIt = reader.getSortedDocValues(MonitorFields.CACHE_ID); + queryIdIt = reader.getSortedDocValues(MonitorFields.QUERY_ID); + mqIt = reader.getSortedDocValues(MonitorFields.MONITOR_QUERY); + versionIt = reader.getNumericDocValues(CommonParams.VERSION_FIELD); + currentDoc = DocIdSetIterator.NO_MORE_DOCS; + } + + public boolean advanceTo(int doc) throws IOException { + currentDoc = doc; + return cacheIdIt.advanceExact(currentDoc); + } + + public String getQueryId() throws IOException { + queryIdIt.advanceExact(currentDoc); + return queryIdIt.lookupOrd(queryIdIt.ordValue()).utf8ToString(); + } + + public String getCacheId() throws IOException { + return cacheIdIt.lookupOrd(cacheIdIt.ordValue()).utf8ToString(); + } + + public String getMq() throws IOException { + if (mqIt != null && mqIt.advanceExact(currentDoc)) { + return mqIt.lookupOrd(mqIt.ordValue()).utf8ToString(); + } + return reader.document(currentDoc).get(MonitorFields.MONITOR_QUERY); + } + + public long getVersion() throws IOException { + if (versionIt != null && versionIt.advanceExact(currentDoc)) { + return versionIt.longValue(); + } + return 0; + } +} diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchDecoder.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchDecoder.java new file mode 100644 index 00000000000..602c532f58f --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchDecoder.java @@ -0,0 +1,59 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch; + +import java.io.IOException; +import java.util.Map; +import org.apache.lucene.monitor.MonitorQuery; +import org.apache.lucene.monitor.QueryDecomposer; +import org.apache.lucene.monitor.Visitors.QCEVisitor; +import org.apache.solr.core.SolrCore; +import org.apache.solr.savedsearch.search.ReverseSearchComponent; + +public class SavedSearchDecoder { + + private final SolrCore core; + private final QueryDecomposer queryDecomposer; + + public SavedSearchDecoder(SolrCore core) { + this.core = core; + ReverseSearchComponent rsc = + (ReverseSearchComponent) + core.getSearchComponents().get(ReverseSearchComponent.COMPONENT_NAME); + this.queryDecomposer = rsc.getQueryDecomposer(); + } + + private MonitorQuery decode(SavedSearchDataValues savedSearchDataValues) throws IOException { + String id = savedSearchDataValues.getQueryId(); + String queryStr = savedSearchDataValues.getMq(); + var query = SimpleQueryParser.parse(queryStr, core); + return new MonitorQuery(id, query, queryStr, Map.of()); + } + + public QCEVisitor getComponent(SavedSearchDataValues dataValues, String cacheId) + throws IOException { + for (QCEVisitor qce : QCEVisitor.decompose(decode(dataValues), queryDecomposer)) { + if (qce.getCacheId().equals(cacheId)) { + return qce; + } + } + throw new IllegalArgumentException("Corrupt monitorQuery value in index"); + } +} diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchSchemaFields.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchSchemaFields.java new file mode 100644 index 00000000000..9888474e43f --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchSchemaFields.java @@ -0,0 +1,49 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch; + +import org.apache.lucene.monitor.Visitors.MonitorFields; +import org.apache.solr.schema.IndexSchema; +import org.apache.solr.schema.SchemaField; + +public class SavedSearchSchemaFields { + + private final SchemaField cacheId; + private final SchemaField queryId; + private final SchemaField monitorQuery; + + public SavedSearchSchemaFields(IndexSchema indexSchema) { + this.cacheId = indexSchema.getField(MonitorFields.CACHE_ID); + this.queryId = indexSchema.getField(MonitorFields.QUERY_ID); + this.monitorQuery = indexSchema.getField(MonitorFields.MONITOR_QUERY); + } + + public SchemaField getCacheId() { + return cacheId; + } + + public SchemaField getQueryId() { + return queryId; + } + + public SchemaField getMonitorQuery() { + return monitorQuery; + } +} diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SimpleQueryParser.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SimpleQueryParser.java new file mode 100644 index 00000000000..2d7d41626b5 --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SimpleQueryParser.java @@ -0,0 +1,147 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch; + +import java.security.Principal; +import java.util.HashMap; +import java.util.Map; +import org.apache.lucene.search.Query; +import org.apache.solr.common.params.MapSolrParams; +import org.apache.solr.common.params.SolrParams; +import org.apache.solr.common.util.ContentStream; +import org.apache.solr.core.SolrCore; +import org.apache.solr.request.SolrQueryRequest; +import org.apache.solr.schema.IndexSchema; +import org.apache.solr.search.QParser; +import org.apache.solr.search.SolrIndexSearcher; +import org.apache.solr.search.SyntaxError; +import org.apache.solr.util.RTimerTree; + +/** + * Fake Solr request used only in some places which need Solr Requests, but not all methods are + * needed. + */ +public class SimpleQueryParser implements SolrQueryRequest { + + private static final SolrParams EMPTY = new MapSolrParams(Map.of()); + + private final SolrCore solrCore; + private final Map context; + private final IndexSchema schema; + private final RTimerTree timerTree; + + private SimpleQueryParser(SolrCore solrCore) { + this.solrCore = solrCore; + this.schema = solrCore.getLatestSchema(); + context = new HashMap<>(); + this.timerTree = new RTimerTree(); + } + + public static Query parse(String queryStr, SolrCore core) { + try { + return QParser.getParser(queryStr, new SimpleQueryParser(core)).parse(); + } catch (SyntaxError e) { + throw new IllegalStateException("could not parse query", e); + } + } + + @Override + public SolrParams getParams() { + return EMPTY; + } + + @Override + public void setParams(SolrParams params) { + throw new UnsupportedOperationException("SolrQueryRequest:: setParams Not supported."); + } + + @Override + public Iterable getContentStreams() { + throw new UnsupportedOperationException("SolrQueryRequest::getContentStreams Not supported."); + } + + @Override + public SolrParams getOriginalParams() { + return EMPTY; + } + + @Override + public Map getContext() { + return context; + } + + @Override + public void close() { + /* no-op */ + } + + protected final long startTime = System.nanoTime(); + + @Override + public long getStartTime() { + return startTime; + } + + @Override + public RTimerTree getRequestTimer() { + return timerTree; + } + + @Override + public SolrIndexSearcher getSearcher() { + return solrCore.getSearcher().get(); + } + + @Override + public SolrCore getCore() { + return solrCore; + } + + @Override + public IndexSchema getSchema() { + return schema; + } + + @Override + public void updateSchemaToLatest() { + throw new UnsupportedOperationException( + "SolrQueryRequest::updateSchemaToLatest Not supported."); + } + + @Override + public String getParamString() { + throw new UnsupportedOperationException("SolrQueryRequest::getParamString Not supported."); + } + + @Override + public Map getJSON() { + throw new UnsupportedOperationException("SolrQueryRequest::getJSON Not supported."); + } + + @Override + public void setJSON(Map json) { + throw new UnsupportedOperationException("SolrQueryRequest::setJSON Not supported."); + } + + @Override + public Principal getUserPrincipal() { + throw new UnsupportedOperationException("SolrQueryRequest::getUserPrincipal Not supported."); + } +} diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/DefaultSavedSearchCache.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/DefaultSavedSearchCache.java new file mode 100644 index 00000000000..762915619dc --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/DefaultSavedSearchCache.java @@ -0,0 +1,324 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch.cache; + +import static java.util.concurrent.TimeUnit.NANOSECONDS; + +import com.github.benmanes.caffeine.cache.Cache; +import com.github.benmanes.caffeine.cache.Caffeine; +import com.github.benmanes.caffeine.cache.RemovalCause; +import com.github.benmanes.caffeine.cache.RemovalListener; +import java.io.IOException; +import java.time.Duration; +import java.util.Map; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.BiPredicate; +import org.apache.lucene.monitor.Visitors.QCEVisitor; +import org.apache.lucene.monitor.Visitors.QueryTermFilterVisitor; +import org.apache.lucene.util.BytesRef; +import org.apache.lucene.util.RamUsageEstimator; +import org.apache.solr.common.SolrException; +import org.apache.solr.common.SolrException.ErrorCode; +import org.apache.solr.metrics.MetricsMap; +import org.apache.solr.metrics.SolrMetricsContext; +import org.apache.solr.savedsearch.SavedSearchDataValues; +import org.apache.solr.savedsearch.SavedSearchDecoder; +import org.apache.solr.search.CacheRegenerator; +import org.apache.solr.search.SolrCache; +import org.apache.solr.search.SolrCacheBase; +import org.apache.solr.search.SolrIndexSearcher; +import org.apache.solr.util.IOFunction; + +public class DefaultSavedSearchCache extends SolrCacheBase + implements SolrCache, + SavedSearchCache, + RemovalListener { + + private static final long START_HIGH_WATER_MARK = -1; + + private final AtomicReference currentStats = + new AtomicReference<>(CurrentStats.init()); + + private Cache mqCache; + BiPredicate termAcceptor = (__, ___) -> true; + + private SolrMetricsContext solrMetricsContext; + private long generationTimeMs; + private long priorLookups; + private long priorHits; + private long cumulativeGenerationTimeMs; + private long cumulativeDocVisits; + + long docVisits; + // only needs to be an approximation + long versionHighWaterMark = START_HIGH_WATER_MARK; + private int initialSize; + private int maxSize; + private int maxRamMB; + + @Override + public VersionedQueryCacheEntry computeIfStale( + SavedSearchDataValues dataValues, SavedSearchDecoder decoder) throws IOException { + return mqCacheMap() + .compute( + dataValues.getCacheId(), + (cacheId, prevEntry) -> compute(cacheId, prevEntry, dataValues, decoder)); + } + + @Override + public boolean acceptTerm(String field, BytesRef value) { + return termAcceptor.test(field, value); + } + + private Map mqCacheMap() { + return mqCache.asMap(); + } + + @Override + public Object init(Map args, Object persistence, CacheRegenerator regenerator) { + super.init(args, regenerator); + String str = args.get(MAX_SIZE_PARAM); + maxSize = (str == null) ? 100_000 : Integer.parseInt(str); + str = args.get(MAX_RAM_MB_PARAM); + maxRamMB = (str == null) ? -1 : Integer.parseInt(str); + str = args.get(INITIAL_SIZE_PARAM); + initialSize = Math.min((str == null) ? 10_000 : Integer.parseInt(str), maxSize); + str = args.get(MAX_IDLE_TIME_PARAM); + int maxIdleTimeSec = -1; + if (str != null) { + maxIdleTimeSec = Integer.parseInt(str); + } + mqCache = buildCache(maxIdleTimeSec); + return persistence; + } + + private Cache buildCache(int maxIdleTimeSec) { + Caffeine builder = + Caffeine.newBuilder().initialCapacity(initialSize).removalListener(this).recordStats(); + if (maxIdleTimeSec > 0) { + builder.expireAfterAccess(Duration.ofSeconds(maxIdleTimeSec)); + } + + if (maxRamMB >= 0) { + builder.maximumWeight(maxRamMB * 1024L * 1024L); + builder.weigher( + (k, v) -> + (int) + (RamUsageEstimator.sizeOf(k) + + RamUsageEstimator.sizeOf(v.entry.getMatchQuery()))); + } else { + builder.maximumSize(maxSize); + } + return builder.build(); + } + + @Override + public int size() { + return mqCacheMap().size(); + } + + @Override + public VersionedQueryCacheEntry put(String key, VersionedQueryCacheEntry value) { + return mqCacheMap().put(key, value); + } + + @Override + public VersionedQueryCacheEntry get(String key) { + return mqCacheMap().get(key); + } + + @Override + public VersionedQueryCacheEntry remove(String key) { + return mqCacheMap().remove(key); + } + + @Override + public VersionedQueryCacheEntry computeIfAbsent( + String key, IOFunction mappingFunction) + throws IOException { + return mqCacheMap() + .computeIfAbsent( + key, + _key -> { + try { + return mappingFunction.apply(_key); + } catch (IOException e) { + throw new SolrException(ErrorCode.INVALID_STATE, "Could not update cache", e); + } + }); + } + + @Override + public void clear() { + mqCacheMap().clear(); + } + + @Override + public void warm(SolrIndexSearcher searcher, SolrCache old) { + try { + DefaultSavedSearchCache oldDefaultSavedSearchCache = + old instanceof DefaultSavedSearchCache ? (DefaultSavedSearchCache) old : null; + if (oldDefaultSavedSearchCache != null) { + mqCache = oldDefaultSavedSearchCache.mqCache; + versionHighWaterMark = oldDefaultSavedSearchCache.versionHighWaterMark; + } + if (regenerator != null) { + long nanoStart = System.nanoTime(); + regenerator.regenerateItem(searcher, this, old, null, null); + generationTimeMs = NANOSECONDS.toMillis(System.nanoTime() - nanoStart); + } + termAcceptor = new QueryTermFilterVisitor(searcher.getIndexReader()); + if (oldDefaultSavedSearchCache != null) { + var oldStats = oldDefaultSavedSearchCache.currentStats.get(); + priorHits = oldDefaultSavedSearchCache.priorHits + oldStats.hits; + priorLookups = oldDefaultSavedSearchCache.priorLookups + oldStats.lookups; + cumulativeGenerationTimeMs = + generationTimeMs + oldDefaultSavedSearchCache.cumulativeGenerationTimeMs; + cumulativeDocVisits = oldDefaultSavedSearchCache.cumulativeDocVisits + docVisits; + } + } catch (IOException e) { + throw new SolrException(SolrException.ErrorCode.INVALID_STATE, "could not boostrap cache", e); + } + } + + @Override + public int getMaxSize() { + return maxSize; + } + + @Override + public void setMaxSize(int maxSize) { + throw new UnsupportedOperationException("maxSize is unsupported"); + } + + @Override + public int getMaxRamMB() { + return maxRamMB; + } + + @Override + public void setMaxRamMB(int maxRamMB) { + throw new UnsupportedOperationException("cannot set max RAM Mb"); + } + + @Override + public String getName() { + return name(); + } + + @Override + public String getDescription() { + return "Solr monitor query cache"; + } + + @Override + public void initializeMetrics(SolrMetricsContext parentContext, String scope) { + solrMetricsContext = parentContext.getChildContext(this); + var cacheMap = + new MetricsMap( + map -> { + var stats = currentStats.get(); + map.put(LOOKUPS_PARAM, stats.lookups); + map.put(HITS_PARAM, stats.hits); + map.put(HIT_RATIO_PARAM, rate(stats.hits, stats.lookups)); + map.put(SIZE_PARAM, size()); + map.put(MAX_RAM_MB_PARAM, getMaxRamMB()); + map.put(MAX_SIZE_PARAM, getMaxSize()); + map.put("generation_time", generationTimeMs); + map.put("doc_visits", docVisits); + long cumulativeLookups = priorLookups + stats.lookups; + long cumulativeHits = priorHits + stats.hits; + map.put("cumulative_lookups", cumulativeLookups); + map.put("cumulative_hits", cumulativeHits); + map.put("cumulative_generation_time", cumulativeGenerationTimeMs); + map.put("cumulative_hitratio", rate(cumulativeHits, cumulativeLookups)); + map.put( + "cumulative_generation_overhead", + rate(cumulativeGenerationTimeMs, cumulativeHits)); + map.put("version_high_water_mark", String.valueOf(versionHighWaterMark)); + map.put("cumulative_doc_visits", cumulativeDocVisits); + }); + solrMetricsContext.gauge(cacheMap, true, scope, getCategory().toString()); + } + + public int getInitialSize() { + return initialSize; + } + + private static double rate(long num, long den) { + return den == 0 ? 1.0 : (double) num / den; + } + + @Override + public SolrMetricsContext getSolrMetricsContext() { + return solrMetricsContext; + } + + private VersionedQueryCacheEntry compute( + String cacheId, + VersionedQueryCacheEntry prevEntry, + SavedSearchDataValues dataValues, + SavedSearchDecoder decoder) { + try { + var version = dataValues.getVersion(); + if (prevEntry == null || version > prevEntry.version) { + QCEVisitor component = decoder.getComponent(dataValues, cacheId); + currentStats.updateAndGet(CurrentStats::miss); + return new VersionedQueryCacheEntry(component, version); + } + if (version == prevEntry.version) { + currentStats.updateAndGet(CurrentStats::hit); + } else { + currentStats.updateAndGet(CurrentStats::miss); + } + return prevEntry; + } catch (Exception e) { + throw new SolrException(ErrorCode.INVALID_STATE, "Failed to update SavedSearchCache", e); + } + } + + @Override + public void onRemoval(String key, VersionedQueryCacheEntry value, RemovalCause cause) { + /* TODO revisit */ + } + + private static final class CurrentStats { + + private final long hits; + private final long lookups; + + private CurrentStats(long hits, long lookups) { + this.hits = hits; + this.lookups = lookups; + } + + private static CurrentStats init() { + return new CurrentStats(0, 0); + } + + private static CurrentStats hit(CurrentStats old) { + return new CurrentStats(old.hits + 1, old.lookups + 1); + } + + private static CurrentStats miss(CurrentStats old) { + return new CurrentStats(old.hits, old.lookups + 1); + } + } +} diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SavedSearchCache.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SavedSearchCache.java new file mode 100644 index 00000000000..32208f47172 --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SavedSearchCache.java @@ -0,0 +1,33 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch.cache; + +import java.io.IOException; +import org.apache.lucene.util.BytesRef; +import org.apache.solr.savedsearch.SavedSearchDataValues; +import org.apache.solr.savedsearch.SavedSearchDecoder; + +public interface SavedSearchCache { + + VersionedQueryCacheEntry computeIfStale( + SavedSearchDataValues dataValues, SavedSearchDecoder decoder) throws IOException; + + boolean acceptTerm(String field, BytesRef value); +} diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SavedSearchLatestRegenerator.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SavedSearchLatestRegenerator.java new file mode 100644 index 00000000000..71655001129 --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SavedSearchLatestRegenerator.java @@ -0,0 +1,93 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch.cache; + +import java.io.IOException; +import org.apache.lucene.document.LongPoint; +import org.apache.lucene.index.LeafReaderContext; +import org.apache.lucene.search.IndexSearcher; +import org.apache.lucene.search.Query; +import org.apache.solr.common.params.CommonParams; +import org.apache.solr.savedsearch.SavedSearchDataValues; +import org.apache.solr.savedsearch.SavedSearchDecoder; +import org.apache.solr.search.CacheRegenerator; +import org.apache.solr.search.SolrCache; +import org.apache.solr.search.SolrIndexSearcher; + +public class SavedSearchLatestRegenerator implements CacheRegenerator { + + private static final int MAX_BATCH_SIZE = 1 << 10; + + @Override + public boolean regenerateItem( + SolrIndexSearcher searcher, + SolrCache newCache, + SolrCache oldCache, + K oldKey, + V oldVal) + throws IOException { + if (!(newCache instanceof DefaultSavedSearchCache)) { + throw new IllegalArgumentException( + this.getClass().getSimpleName() + + " only supports " + + DefaultSavedSearchCache.class.getSimpleName()); + } + var cache = (DefaultSavedSearchCache) newCache; + var reader = searcher.getIndexReader(); + int batchSize = Math.min(MAX_BATCH_SIZE, cache.getInitialSize()); + var topDocs = + new IndexSearcher(searcher.getTopReaderContext()) + .search(versionRangeQuery(cache), batchSize) + .scoreDocs; + int batchesRemaining = cache.getInitialSize() / batchSize - 1; + SavedSearchDecoder decoder = new SavedSearchDecoder(searcher.getCore()); + while (topDocs.length > 0 && batchesRemaining > 0) { + int docIndex = 0; + for (LeafReaderContext ctx : reader.leaves()) { + SavedSearchDataValues dataValues = new SavedSearchDataValues(ctx); + int shiftedMax = ctx.reader().maxDoc() + ctx.docBase; + while (docIndex < topDocs.length + && topDocs[docIndex].doc >= ctx.docBase + && topDocs[docIndex].doc < shiftedMax) { + int doc = topDocs[docIndex].doc - ctx.docBase; + docIndex++; + if (dataValues.advanceTo(doc)) { + cache.computeIfStale(dataValues, decoder); + } + cache.versionHighWaterMark = + Math.max(cache.versionHighWaterMark, dataValues.getVersion()); + cache.docVisits++; + } + } + var scoreDoc = topDocs[topDocs.length - 1]; + topDocs = + new IndexSearcher(searcher.getTopReaderContext()) + .searchAfter(scoreDoc, versionRangeQuery(cache), batchSize) + .scoreDocs; + batchesRemaining--; + } + return false; + } + + private static Query versionRangeQuery(DefaultSavedSearchCache cache) { + return LongPoint.newRangeQuery( + CommonParams.VERSION_FIELD, cache.versionHighWaterMark, Long.MAX_VALUE); + } +} diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/VersionedQueryCacheEntry.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/VersionedQueryCacheEntry.java new file mode 100644 index 00000000000..2fd58f06f66 --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/VersionedQueryCacheEntry.java @@ -0,0 +1,33 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch.cache; + +import org.apache.lucene.monitor.Visitors.QCEVisitor; + +public class VersionedQueryCacheEntry { + + public final QCEVisitor entry; + public final long version; + + public VersionedQueryCacheEntry(QCEVisitor entry, long version) { + this.entry = entry; + this.version = version; + } +} diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/package-info.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/package-info.java new file mode 100644 index 00000000000..a9afe9f7538 --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/package-info.java @@ -0,0 +1,21 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +/** This package contains caching logic for Solr's lucene-monitor integration. */ +package org.apache.solr.savedsearch.cache; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/package-info.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/package-info.java new file mode 100644 index 00000000000..77d399ca08d --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/package-info.java @@ -0,0 +1,21 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +/** This package contains Solr's lucene monitor integration. */ +package org.apache.solr.savedsearch; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/PresearcherFactory.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/PresearcherFactory.java new file mode 100644 index 00000000000..0452b891537 --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/PresearcherFactory.java @@ -0,0 +1,145 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch.search; + +import java.lang.reflect.Constructor; +import java.util.List; +import java.util.Set; +import org.apache.lucene.monitor.CustomQueryHandler; +import org.apache.lucene.monitor.MultipassTermFilteredPresearcher; +import org.apache.lucene.monitor.Presearcher; +import org.apache.lucene.monitor.TermFilteredPresearcher; +import org.apache.lucene.monitor.TermWeightor; +import org.apache.lucene.util.ResourceLoader; +import org.apache.solr.savedsearch.AliasingPresearcher; + +public class PresearcherFactory { + + // The default prefix is long because we don't want it to clash + // with a user-defined name pattern and the longest one wins. + // {@link + // https://cwiki.apache.org/confluence/display/solr/SchemaXml#Dynamic_fields:~:text=Longer%20patterns%20will%20be%20matched%20first} + // In the worst case this can be overridden by the user but ideally this never comes up. + public static final String DEFAULT_ALIAS_PREFIX = + "_________________________________________________saved_search_alias_"; + + public static final String TERM_FILTERED = TermFilteredPresearcher.class.getSimpleName(); + public static final String MULTI_PASS_TERM_FILTERED = + MultipassTermFilteredPresearcher.class.getSimpleName(); + + private PresearcherFactory() {} + + static Presearcher build( + ResourceLoader resourceLoader, PresearcherParameters presearcherParameters) { + Presearcher presearcher; + String type = presearcherParameters.presearcherType; + if (TERM_FILTERED.equals(type) || MULTI_PASS_TERM_FILTERED.equals(type)) { + TermWeightor weightor = + constructZeroArgClass( + resourceLoader, + TermWeightor.class, + presearcherParameters.termWeightorType, + TermFilteredPresearcher.DEFAULT_WEIGHTOR); + List customQueryHandlers = List.of(); + Set filterFields = Set.of(); + if (TERM_FILTERED.equals(type)) { + if (presearcherParameters.applyFieldNameAlias) { + presearcher = + AliasingPresearcher.TermFiltered.build( + weightor, customQueryHandlers, filterFields, presearcherParameters.aliasPrefix); + } else { + presearcher = new TermFilteredPresearcher(weightor, customQueryHandlers, filterFields); + } + } else { + if (presearcherParameters.applyFieldNameAlias) { + presearcher = + AliasingPresearcher.MultiPassTermFiltered.build( + presearcherParameters.numberOfPasses, + presearcherParameters.minWeight, + weightor, + customQueryHandlers, + filterFields, + presearcherParameters.aliasPrefix); + } else { + presearcher = + new MultipassTermFilteredPresearcher( + presearcherParameters.numberOfPasses, + presearcherParameters.minWeight, + weightor, + customQueryHandlers, + filterFields); + } + } + } else { + presearcher = + constructZeroArgClass(resourceLoader, Presearcher.class, type, Presearcher.NO_FILTERING); + } + return presearcher; + } + + private static T constructZeroArgClass( + ResourceLoader loader, Class expectedType, String typeName, T defaultVal) { + if (typeName == null) { + return defaultVal; + } + try { + Class implClass = loader.findClass(typeName, expectedType); + Constructor c = implClass.getConstructor(); + return c.newInstance(); + } catch (Exception e) { + throw new IllegalStateException( + "Could not construct custom " + expectedType.getSimpleName() + " of type " + typeName, e); + } + } + + public static class PresearcherParameters { + + private String presearcherType; + private String termWeightorType; + private boolean applyFieldNameAlias = false; + private int numberOfPasses = 0; + private float minWeight = 0; + private String aliasPrefix = DEFAULT_ALIAS_PREFIX; + + public void setPresearcherType(String presearcherType) { + this.presearcherType = presearcherType; + } + + public void setTermWeightorType(String termWeightorType) { + this.termWeightorType = termWeightorType; + } + + public void setApplyFieldNameAlias(boolean applyFieldNameAlias) { + this.applyFieldNameAlias = applyFieldNameAlias; + } + + public void setNumberOfPasses(int numberOfPasses) { + this.numberOfPasses = numberOfPasses; + } + + public void setMinWeight(float minWeight) { + this.minWeight = minWeight; + } + + public void setAliasPrefix(String aliasPrefix) { + this.aliasPrefix = aliasPrefix; + } + } +} diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchComponent.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchComponent.java new file mode 100644 index 00000000000..9933c740b0b --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchComponent.java @@ -0,0 +1,284 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch.search; + +import static org.apache.solr.savedsearch.search.PresearcherFactory.DEFAULT_ALIAS_PREFIX; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.BiPredicate; +import java.util.function.Function; +import org.apache.lucene.document.Document; +import org.apache.lucene.index.LeafReader; +import org.apache.lucene.monitor.CandidateMatcher; +import org.apache.lucene.monitor.Presearcher; +import org.apache.lucene.monitor.QueryDecomposer; +import org.apache.lucene.monitor.QueryMatch; +import org.apache.lucene.monitor.TermFilteredPresearcher; +import org.apache.lucene.monitor.Visitors.DocumentBatchVisitor; +import org.apache.lucene.monitor.Visitors.MonitorFields; +import org.apache.lucene.search.IndexSearcher; +import org.apache.lucene.search.Query; +import org.apache.lucene.util.BytesRef; +import org.apache.solr.common.SolrException; +import org.apache.solr.common.util.NamedList; +import org.apache.solr.common.util.SimpleOrderedMap; +import org.apache.solr.core.SolrCore; +import org.apache.solr.handler.component.DebugComponent; +import org.apache.solr.handler.component.QueryComponent; +import org.apache.solr.handler.component.ResponseBuilder; +import org.apache.solr.handler.loader.JsonLoader; +import org.apache.solr.savedsearch.AliasingPresearcher; +import org.apache.solr.savedsearch.SavedSearchDecoder; +import org.apache.solr.savedsearch.cache.DefaultSavedSearchCache; +import org.apache.solr.savedsearch.cache.SavedSearchCache; +import org.apache.solr.schema.IndexSchema; +import org.apache.solr.schema.SchemaField; +import org.apache.solr.update.DocumentBuilder; +import org.apache.solr.util.SolrPluginUtils; +import org.apache.solr.util.plugin.SolrCoreAware; + +public class ReverseSearchComponent extends QueryComponent implements SolrCoreAware { + + public static final String COMPONENT_NAME = "reverseSearch"; + + private static final String SAVED_SEARCH_CACHE_NAME_KEY = "savedSearchCacheName"; + private static final String SAVED_SEARCH_CACHE_NAME_DEFAULT = "savedSearchCache"; + private static final String REVERSE_SEARCH_DOCUMENTS_KEY = "reverseSearchDocuments"; + private String savedSearchCacheName = SAVED_SEARCH_CACHE_NAME_DEFAULT; + + private QueryDecomposer queryDecomposer; + private Presearcher presearcher; + private PresearcherFactory.PresearcherParameters presearcherParameters; + + @Override + public void init(NamedList args) { + super.init(args); + Object savedSearchCacheName = args.remove(SAVED_SEARCH_CACHE_NAME_KEY); + if (savedSearchCacheName != null) { + this.savedSearchCacheName = (String) savedSearchCacheName; + } + presearcherParameters = new PresearcherFactory.PresearcherParameters(); + SolrPluginUtils.invokeSetters(presearcherParameters, args); + } + + @Override + public void prepare(ResponseBuilder rb) throws IOException { + super.prepare(rb); + try (final DocumentBatchVisitor documentBatchVisitor = + documentBatchVisitor(rb.req.getJSON(), rb.req.getSchema())) { + final LeafReader documentBatch = documentBatchVisitor.get(); + + final SavedSearchCache savedSearchCache = + (DefaultSavedSearchCache) rb.req.getSearcher().getCache(this.savedSearchCacheName); + + final BiPredicate termAcceptor; + if (savedSearchCache == null) { + termAcceptor = (__, ___) -> true; + } else { + termAcceptor = savedSearchCache::acceptTerm; + } + final Query preFilterQuery = presearcher.buildQuery(documentBatch, termAcceptor); + rb.setQuery(reverseSearchQuery(preFilterQuery, rb, documentBatch, savedSearchCache)); + } + } + + private static ReverseSearchQuery reverseSearchQuery( + Query preFilterQuery, + ResponseBuilder rb, + LeafReader documentBatch, + SavedSearchCache savedSearchCache) { + final SavedSearchDecoder savedSearchDecoder = new SavedSearchDecoder(rb.req.getCore()); + + final SolrMatcherSink solrMatcherSink = + new DefaultSolrMatcherSink<>( + QueryMatch.SIMPLE_MATCHER::createMatcher, new IndexSearcher(documentBatch)); + rb.req.getContext().put(SolrMatcherSink.class.getSimpleName(), solrMatcherSink); + + final ReverseSearchQuery.ReverseSearchContext context = + new ReverseSearchQuery.ReverseSearchContext( + savedSearchCache, savedSearchDecoder, solrMatcherSink); + + return new ReverseSearchQuery(context, preFilterQuery); + } + + @Override + public void process(ResponseBuilder rb) throws IOException { + super.process(rb); + SolrMatcherSink solrMatcherSink = + (SolrMatcherSink) rb.req.getContext().get(SolrMatcherSink.class.getSimpleName()); + if (rb.isDebug() && solrMatcherSink != null) { + ReverseSearchQuery.Metadata metadata = solrMatcherSink.getMetadata(); + DebugComponent.CustomDebugInfoSources debugInfoSources = + (DebugComponent.CustomDebugInfoSources) + rb.req + .getContext() + .computeIfAbsent( + DebugComponent.CustomDebugInfoSources.KEY, + key -> new DebugComponent.CustomDebugInfoSources()); + SimpleOrderedMap info = new SimpleOrderedMap<>(); + info.add("queriesRun", metadata.getQueriesRun()); + debugInfoSources.add(new DebugComponent.CustomDebugInfoSource("reverse-search-debug", info)); + } + } + + @SuppressWarnings({"unchecked"}) + private static DocumentBatchVisitor documentBatchVisitor( + Map json, IndexSchema indexSchema) { + Object jsonParams = json.get("params"); + if (!(jsonParams instanceof Map)) { + throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "need params"); + } + Map paramMap = (Map) jsonParams; + Object documents = paramMap.get(REVERSE_SEARCH_DOCUMENTS_KEY); + if (!(documents instanceof List)) { + throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "need documents list"); + } + List luceneDocs = new ArrayList<>(); + for (Object document : (List) documents) { + if (!(document instanceof Map) + || !((Map) document).keySet().stream().allMatch(key -> key instanceof String)) { + throw new SolrException( + SolrException.ErrorCode.BAD_REQUEST, "document needs to be a string-keyed map"); + } + Map docAsMap = (Map) document; + docAsMap.putIfAbsent(indexSchema.getUniqueKeyField().getName(), UUID.randomUUID().toString()); + var solrInputDoc = JsonLoader.buildDoc((Map) document); + var luceneDoc = DocumentBuilder.toDocument(solrInputDoc, indexSchema); + luceneDocs.add(luceneDoc); + } + return DocumentBatchVisitor.of(indexSchema.getIndexAnalyzer(), luceneDocs); + } + + @Override + public String getDescription() { + return "Component that integrates with lucene monitor for reverse search."; + } + + @Override + public void inform(SolrCore core) { + queryDecomposer = new QueryDecomposer(); + presearcher = PresearcherFactory.build(core.getResourceLoader(), presearcherParameters); + var schema = core.getLatestSchema(); + if (presearcher instanceof AliasingPresearcher) { + String prefix = ((AliasingPresearcher) presearcher).getPrefix() + "*"; + String maxLengthPattern = + Arrays.stream(schema.getDynamicFieldPrototypes()) + .map(SchemaField::getName) + .max(Comparator.comparingInt(String::length)) + .orElse(""); + if (!maxLengthPattern.equals(prefix) && prefix.length() <= maxLengthPattern.length()) { + throw new IllegalStateException( + "Dynamic field pattern " + + maxLengthPattern + + " is incompatible with presearcher alias pattern " + + prefix + + ". Increase the length of presearcher alias prefix to be at least" + + (maxLengthPattern.length() + 1) + + " characters, i.e. set aliasPrefix to " + + "_".repeat(maxLengthPattern.length() - DEFAULT_ALIAS_PREFIX.length() + 1) + + DEFAULT_ALIAS_PREFIX + + " and update the schema accordingly. Refer to documentation on overriding aliasPrefix in " + + this.getClass().getSimpleName()); + } + var fieldType = schema.getDynamicFieldType(prefix); + if (!fieldType.isTokenized() || !fieldType.isMultiValued()) { + throw new IllegalStateException( + "presearcher-aliased field must be tokenized and multi-valued."); + } + if (!fieldType.isTokenized() || !fieldType.isMultiValued()) { + throw new IllegalStateException( + "presearcher-aliased field must be tokenized and multi-valued."); + } + } + + for (String fieldName : MonitorFields.REQUIRED_MONITOR_SCHEMA_FIELDS) { + var field = schema.getFieldOrNull(fieldName); + if (field == null) { + throw new IllegalStateException( + fieldName + " must be defined in schema for saved search to work."); + } + } + + if (presearcher instanceof TermFilteredPresearcher + || presearcher instanceof AliasingPresearcher) { + var anyTokenField = schema.getFieldOrNull(TermFilteredPresearcher.ANYTOKEN_FIELD); + if (anyTokenField == null || !anyTokenField.tokenized() || !anyTokenField.multiValued()) { + throw new IllegalStateException( + TermFilteredPresearcher.ANYTOKEN_FIELD + " field must be tokenized and multi-valued."); + } + } + } + + public QueryDecomposer getQueryDecomposer() { + return queryDecomposer; + } + + public Presearcher getPresearcher() { + return presearcher; + } + + static class DefaultSolrMatcherSink implements SolrMatcherSink { + + private final Function> matcherFactory; + private final IndexSearcher docBatchSearcher; + private final ConcurrentHashMap.KeySetView metadataSet = + ConcurrentHashMap.newKeySet(); + + DefaultSolrMatcherSink( + Function> matcherFactory, + IndexSearcher docBatchSearcher) { + this.matcherFactory = matcherFactory; + this.docBatchSearcher = docBatchSearcher; + } + + @Override + public boolean matchQuery(String queryId, Query matchQuery, Map metadata) + throws IOException { + var matcher = matcherFactory.apply(docBatchSearcher); + matcher.matchQuery(queryId, matchQuery, metadata); + var matches = matcher.finish(Long.MIN_VALUE, 1); + for (int doc = 0; doc < matches.getBatchSize(); doc++) { + var match = matches.getMatches(doc); + if (!match.isEmpty()) { + return true; + } + } + return false; + } + + @Override + public void captureMetadata(ReverseSearchQuery.Metadata metadata) { + metadataSet.add(metadata); + } + + @Override + public ReverseSearchQuery.Metadata getMetadata() { + return metadataSet.stream() + .reduce(ReverseSearchQuery.Metadata.IDENTITY, ReverseSearchQuery.Metadata::add); + } + } +} diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchHandler.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchHandler.java new file mode 100644 index 00000000000..1b6186ec3d9 --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchHandler.java @@ -0,0 +1,36 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch.search; + +import java.util.ArrayList; +import java.util.List; +import org.apache.solr.handler.component.DebugComponent; +import org.apache.solr.handler.component.SearchHandler; + +public class ReverseSearchHandler extends SearchHandler { + + @Override + protected List getDefaultComponents() { + ArrayList names = new ArrayList<>(1); + names.add(ReverseSearchComponent.COMPONENT_NAME); + names.add(DebugComponent.COMPONENT_NAME); + return names; + } +} diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchQuery.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchQuery.java new file mode 100644 index 00000000000..03e5fb49d7b --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchQuery.java @@ -0,0 +1,305 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch.search; + +import java.io.IOException; +import java.util.Collection; +import org.apache.lucene.index.LeafReaderContext; +import org.apache.lucene.monitor.Visitors.QCEVisitor; +import org.apache.lucene.search.BulkScorer; +import org.apache.lucene.search.ConstantScoreQuery; +import org.apache.lucene.search.DocIdSetIterator; +import org.apache.lucene.search.Explanation; +import org.apache.lucene.search.IndexSearcher; +import org.apache.lucene.search.Matches; +import org.apache.lucene.search.Query; +import org.apache.lucene.search.QueryVisitor; +import org.apache.lucene.search.ScoreMode; +import org.apache.lucene.search.Scorer; +import org.apache.lucene.search.ScorerSupplier; +import org.apache.lucene.search.TwoPhaseIterator; +import org.apache.lucene.search.Weight; +import org.apache.solr.savedsearch.SavedSearchDataValues; +import org.apache.solr.savedsearch.SavedSearchDecoder; +import org.apache.solr.savedsearch.cache.SavedSearchCache; + +class ReverseSearchQuery extends Query { + + private final ReverseSearchContext reverseSearchContext; + private final Query presearchQuery; + + public ReverseSearchQuery(ReverseSearchContext reverseSearchContext, Query presearchQuery) { + this.reverseSearchContext = reverseSearchContext; + this.presearchQuery = presearchQuery; + } + + @Override + public void visit(QueryVisitor visitor) { + presearchQuery.visit(visitor); + } + + @Override + public boolean equals(Object o) { + return this == o; + } + + @Override + public Query rewrite(IndexSearcher indexSearcher) throws IOException { + Query rewritten = presearchQuery.rewrite(indexSearcher); + if (rewritten != presearchQuery) { + return new ReverseSearchQuery(reverseSearchContext, presearchQuery.rewrite(indexSearcher)); + } + return super.rewrite(indexSearcher); + } + + @Override + public int hashCode() { + return System.identityHashCode(this); + } + + @Override + public String toString(String field) { + return this.getClass().getSimpleName() + + "(presearchQuery=" + + presearchQuery.toString(field) + + ")"; + } + + @Override + public Weight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float boost) + throws IOException { + return new ReverseSearchWeight( + this, reverseSearchContext, presearchQuery.createWeight(searcher, scoreMode, boost)); + } + + static class ReverseSearchWeight extends Weight { + + private final ReverseSearchContext reverseSearchContext; + private final Weight presearchWeight; + + ReverseSearchWeight( + Query query, ReverseSearchContext reverseSearchContext, Weight presearchWeight) { + super(query); + this.reverseSearchContext = reverseSearchContext; + this.presearchWeight = presearchWeight; + } + + @Override + public Explanation explain(LeafReaderContext context, int doc) throws IOException { + return presearchWeight.explain(context, doc); + } + + @Override + public Scorer scorer(LeafReaderContext context) throws IOException { + Scorer scorer = presearchWeight.scorer(context); + if (scorer == null) { + return null; + } + return new ReverseSearchScorer(scorer, reverseSearchContext, context); + } + + @Override + public boolean isCacheable(LeafReaderContext ctx) { + return false; + } + + @Override + public int count(LeafReaderContext context) throws IOException { + return presearchWeight.count(context); + } + + @Override + public BulkScorer bulkScorer(LeafReaderContext context) throws IOException { + return super.bulkScorer(context); + } + + @Override + public ScorerSupplier scorerSupplier(LeafReaderContext context) throws IOException { + Scorer scorer = scorer(context); + if (scorer == null) { + return null; + } + return new ScorerSupplier() { + + @Override + public Scorer get(long leadCost) { + return scorer; + } + + @Override + public long cost() { + return Long.MAX_VALUE; + } + }; + } + + @Override + public Matches matches(LeafReaderContext context, int doc) throws IOException { + return presearchWeight.matches(context, doc); + } + } + + static class ReverseSearchScorer extends Scorer { + private static final float MATCH_COST = 100.0f; + + private final Scorer presearchScorer; + private final SavedSearchCache savedSearchCache; + private final SavedSearchDecoder queryDecoder; + private final SolrMatcherSink matcherSink; + private final Metadata metadata; + private final SavedSearchDataValues dataValues; + + ReverseSearchScorer( + Scorer presearchScorer, + ReverseSearchContext reverseSearchContext, + LeafReaderContext leafReaderContext) + throws IOException { + super(presearchScorer.getWeight()); + this.presearchScorer = presearchScorer; + this.savedSearchCache = reverseSearchContext.queryCache; + this.queryDecoder = reverseSearchContext.queryDecoder; + this.matcherSink = reverseSearchContext.solrMatcherSink; + this.metadata = new Metadata(); + matcherSink.captureMetadata(metadata); + this.dataValues = new SavedSearchDataValues(leafReaderContext); + } + + @Override + public DocIdSetIterator iterator() { + return presearchScorer.iterator(); + } + + @Override + public float getMaxScore(int upTo) throws IOException { + return presearchScorer.getMaxScore(upTo); + } + + @Override + public float score() throws IOException { + return presearchScorer.score(); + } + + @Override + public int docID() { + return presearchScorer.docID(); + } + + @Override + public Weight getWeight() { + return presearchScorer.getWeight(); + } + + @Override + public int advanceShallow(int target) throws IOException { + return presearchScorer.advanceShallow(target); + } + + @Override + public float smoothingScore(int docId) throws IOException { + return presearchScorer.smoothingScore(docId); + } + + @Override + public void setMinCompetitiveScore(float minScore) throws IOException { + presearchScorer.setMinCompetitiveScore(minScore); + } + + @Override + public Collection getChildren() throws IOException { + return presearchScorer.getChildren(); + } + + @Override + public TwoPhaseIterator twoPhaseIterator() { + + return new TwoPhaseIterator(presearchScorer.iterator()) { + + private String lastQueryId; + + @Override + public boolean matches() throws IOException { + metadata.queriesRun++; + int doc = approximation.docID(); + dataValues.advanceTo(doc); + var entry = getEntry(dataValues); + var queryId = dataValues.getQueryId(); + var originalMatchQuery = entry.getMatchQuery(); + + var matchQuery = new ConstantScoreQuery(originalMatchQuery); + + boolean isMatch = matcherSink.matchQuery(queryId, matchQuery, entry.getMetadata()); + if (isMatch && !queryId.equals(lastQueryId)) { + lastQueryId = queryId; + return true; + } + return false; + } + + private QCEVisitor getEntry(SavedSearchDataValues dataValues) throws IOException { + var versionedEntry = + savedSearchCache == null + ? null + : savedSearchCache.computeIfStale(dataValues, queryDecoder); + return (versionedEntry == null || versionedEntry.version != dataValues.getVersion()) + ? queryDecoder.getComponent(dataValues, dataValues.getCacheId()) + : versionedEntry.entry; + } + + @Override + public float matchCost() { + return MATCH_COST; + } + }; + } + } + + static class ReverseSearchContext { + + private final SavedSearchCache queryCache; + private final SavedSearchDecoder queryDecoder; + private final SolrMatcherSink solrMatcherSink; + + ReverseSearchContext( + SavedSearchCache queryCache, + SavedSearchDecoder queryDecoder, + SolrMatcherSink solrMatcherSink) { + this.queryCache = queryCache; + this.queryDecoder = queryDecoder; + this.solrMatcherSink = solrMatcherSink; + } + } + + static class Metadata { + + static final Metadata IDENTITY = new Metadata(); + + private int queriesRun; + + int getQueriesRun() { + return queriesRun; + } + + Metadata add(Metadata metadata) { + Metadata result = new Metadata(); + result.queriesRun = this.queriesRun + metadata.queriesRun; + return result; + } + } +} diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/SolrMatcherSink.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/SolrMatcherSink.java new file mode 100644 index 00000000000..1fd2a1c9fd1 --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/SolrMatcherSink.java @@ -0,0 +1,34 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch.search; + +import java.io.IOException; +import java.util.Map; +import org.apache.lucene.search.Query; + +interface SolrMatcherSink { + + boolean matchQuery(String queryId, Query matchQuery, Map metadata) + throws IOException; + + void captureMetadata(ReverseSearchQuery.Metadata metadata); + + ReverseSearchQuery.Metadata getMetadata(); +} diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/package-info.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/package-info.java new file mode 100644 index 00000000000..0fd177d0137 --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/package-info.java @@ -0,0 +1,21 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +/** This package contains search logic for Solr's lucene-monitor integration. */ +package org.apache.solr.savedsearch.search; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/SavedSearchUpdateProcessorFactory.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/SavedSearchUpdateProcessorFactory.java new file mode 100644 index 00000000000..74e06d499ca --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/SavedSearchUpdateProcessorFactory.java @@ -0,0 +1,299 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch.update; + +import java.io.IOException; +import java.io.Reader; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import org.apache.lucene.analysis.Analyzer; +import org.apache.lucene.analysis.TokenStream; +import org.apache.lucene.document.Document; +import org.apache.lucene.document.Field; +import org.apache.lucene.document.InvertableType; +import org.apache.lucene.document.StoredValue; +import org.apache.lucene.index.DocValuesType; +import org.apache.lucene.index.IndexableField; +import org.apache.lucene.index.IndexableFieldType; +import org.apache.lucene.monitor.MonitorQuery; +import org.apache.lucene.monitor.Presearcher; +import org.apache.lucene.monitor.QueryDecomposer; +import org.apache.lucene.monitor.Visitors.MonitorFields; +import org.apache.lucene.monitor.Visitors.QCEVisitor; +import org.apache.lucene.util.BytesRef; +import org.apache.solr.common.SolrException; +import org.apache.solr.common.SolrInputDocument; +import org.apache.solr.common.params.CommonParams; +import org.apache.solr.common.util.JavaBinCodec; +import org.apache.solr.core.SolrCore; +import org.apache.solr.request.SolrQueryRequest; +import org.apache.solr.response.SolrQueryResponse; +import org.apache.solr.savedsearch.SavedSearchSchemaFields; +import org.apache.solr.savedsearch.SimpleQueryParser; +import org.apache.solr.savedsearch.search.ReverseSearchComponent; +import org.apache.solr.schema.IndexSchema; +import org.apache.solr.schema.SchemaField; +import org.apache.solr.update.AddUpdateCommand; +import org.apache.solr.update.processor.UpdateRequestProcessor; +import org.apache.solr.update.processor.UpdateRequestProcessorFactory; +import org.apache.solr.util.plugin.SolrCoreAware; + +public class SavedSearchUpdateProcessorFactory extends UpdateRequestProcessorFactory + implements SolrCoreAware { + + private QueryDecomposer queryDecomposer; + private Presearcher presearcher; + + @Override + public UpdateRequestProcessor getInstance( + SolrQueryRequest req, SolrQueryResponse rsp, UpdateRequestProcessor next) { + return new SavedSearchUpdateRequestProcessor(next, req.getCore(), queryDecomposer, presearcher); + } + + @Override + public void inform(SolrCore core) { + ReverseSearchComponent rsc = + (ReverseSearchComponent) + core.getSearchComponents().get(ReverseSearchComponent.COMPONENT_NAME); + presearcher = rsc.getPresearcher(); + queryDecomposer = rsc.getQueryDecomposer(); + } + + static class SavedSearchUpdateRequestProcessor extends UpdateRequestProcessor { + + private final SolrCore core; + private final IndexSchema indexSchema; + private final QueryDecomposer queryDecomposer; + private final Presearcher presearcher; + private final SavedSearchSchemaFields savedSearchSchemaFields; + private final Set allowedFieldNames; + + public SavedSearchUpdateRequestProcessor( + UpdateRequestProcessor next, + SolrCore core, + QueryDecomposer queryDecomposer, + Presearcher presearcher) { + super(next); + this.core = core; + this.indexSchema = core.getLatestSchema(); + this.queryDecomposer = queryDecomposer; + this.presearcher = presearcher; + this.savedSearchSchemaFields = new SavedSearchSchemaFields(indexSchema); + this.allowedFieldNames = + Set.of( + MonitorFields.MONITOR_QUERY, + indexSchema.getUniqueKeyField().getName(), + CommonParams.VERSION_FIELD); + } + + @Override + public void processAdd(AddUpdateCommand cmd) throws IOException { + var solrInputDocument = cmd.getSolrInputDocument(); + String idFieldName = indexSchema.getUniqueKeyField().getName(); + var queryId = (String) solrInputDocument.getFieldValue(idFieldName); + var queryFieldValue = solrInputDocument.getFieldValue(MonitorFields.MONITOR_QUERY); + if (queryFieldValue == null) { + throw new SolrException( + SolrException.ErrorCode.BAD_REQUEST, + "Document is missing mandatory " + + MonitorFields.MONITOR_QUERY + + " field which is required by " + + getClass().getSimpleName() + + "."); + } + var unsupportedFields = + solrInputDocument.getFieldNames().stream() + .filter(name -> !allowedFieldNames.contains(name)) + .collect(Collectors.joining(", ")); + if (!unsupportedFields.isEmpty()) { + throw new SolrException( + SolrException.ErrorCode.BAD_REQUEST, + "Request contains fields not supported by " + + getClass().getSimpleName() + + ": " + + unsupportedFields); + } + List children = + Optional.of(queryFieldValue) + .filter(String.class::isInstance) + .map(String.class::cast) + .map( + queryStr -> + new MonitorQuery( + queryId, SimpleQueryParser.parse(queryStr, core), queryStr, Map.of())) + .stream() + .flatMap(this::decompose) + .map(this::toSolrInputDoc) + .collect(Collectors.toList()); + if (children.isEmpty()) { + throw new SolrException( + SolrException.ErrorCode.INVALID_STATE, "Query could not be decomposed"); + } + SolrInputDocument firstChild = children.get(0); + if (solrInputDocument.hasChildDocuments()) { + solrInputDocument.getChildDocuments().clear(); + } + solrInputDocument.addChildDocuments(children.stream().skip(1).collect(Collectors.toList())); + if (solrInputDocument.hasChildDocuments()) { + solrInputDocument + .getChildDocuments() + .forEach( + child -> child.setField(idFieldName, child.getFieldValue(MonitorFields.CACHE_ID))); + } + copyFirstChildToParent(solrInputDocument, firstChild); + super.processAdd(cmd); + } + + private void copyFirstChildToParent(SolrInputDocument parent, SolrInputDocument firstChild) { + parent.setField( + indexSchema.getUniqueKeyField().getName(), + firstChild.getFieldValue(MonitorFields.CACHE_ID)); + for (var firstChildField : firstChild) { + parent.setField(firstChildField.getName(), firstChildField.getValue()); + } + } + + private Stream decompose(MonitorQuery monitorQuery) { + return QCEVisitor.decompose(monitorQuery, queryDecomposer).stream() + .map( + qce -> { + Document doc = + presearcher.indexQuery(qce.getMatchQuery(), monitorQuery.getMetadata()); + doc.add(savedSearchSchemaFields.getQueryId().createField(qce.getQueryId())); + doc.add(savedSearchSchemaFields.getCacheId().createField(qce.getCacheId())); + doc.add( + savedSearchSchemaFields + .getMonitorQuery() + .createField(monitorQuery.getQueryString())); + return doc; + }); + } + + private SolrInputDocument toSolrInputDoc(Document subDocument) { + SolrInputDocument out = new SolrInputDocument(); + for (var f : subDocument.getFields()) { + Object existing = out.get(f.name()); + if (existing == null) { + SchemaField sf = indexSchema.getFieldOrNull(f.name()); + if (sf != null && sf.multiValued()) { + List vals = new ArrayList<>(); + if (f.fieldType().docValuesType() == DocValuesType.SORTED_NUMERIC) { + vals.add(sf.getType().toObject(f)); + } else { + vals.add(materialize(f)); + } + out.setField(f.name(), vals); + } else { + out.setField(f.name(), materialize(f)); + } + } else { + out.addField(f.name(), materialize(f)); + } + } + return out; + } + + private static Object materialize(IndexableField in) { + if (in instanceof Field && ((Field) in).tokenStreamValue() != null) { + return new DerivedSkipTLogField((Field) in); + } + if (in.numericValue() != null) { + return in.numericValue(); + } + if (in.binaryValue() != null) { + return in.binaryValue(); + } + if (in.stringValue() != null) { + return in.stringValue(); + } + throw new IllegalArgumentException("could not clone field " + in.name()); + } + + private static class DerivedSkipTLogField + implements IndexableField, JavaBinCodec.ObjectResolver { + + private final Field ref; + + public DerivedSkipTLogField(Field ref) { + this.ref = ref; + } + + @Override + public Object resolve(Object o, JavaBinCodec codec) { + return ""; + } + + @Override + public String name() { + return ref.name(); + } + + @Override + public IndexableFieldType fieldType() { + return ref.fieldType(); + } + + @Override + public TokenStream tokenStream(Analyzer analyzer, TokenStream reuse) { + return ref.tokenStream(analyzer, reuse); + } + + @Override + public BytesRef binaryValue() { + return ref.binaryValue(); + } + + @Override + public String stringValue() { + return ref.stringValue(); + } + + @Override + public CharSequence getCharSequenceValue() { + return ref.getCharSequenceValue(); + } + + @Override + public Reader readerValue() { + return ref.readerValue(); + } + + @Override + public Number numericValue() { + return ref.numericValue(); + } + + @Override + public StoredValue storedValue() { + return null; + } + + @Override + public InvertableType invertableType() { + return InvertableType.TOKEN_STREAM; + } + } + } +} diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/package-info.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/package-info.java new file mode 100644 index 00000000000..e87f29ee76c --- /dev/null +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/package-info.java @@ -0,0 +1,21 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +/** This package contains update logic for Solr's lucene-monitor integration. */ +package org.apache.solr.savedsearch.update; diff --git a/solr/modules/saved-search/src/test-files/monitor/BigDisjunctionQuery.xml b/solr/modules/saved-search/src/test-files/monitor/BigDisjunctionQuery.xml new file mode 100644 index 00000000000..49d26cece00 --- /dev/null +++ b/solr/modules/saved-search/src/test-files/monitor/BigDisjunctionQuery.xml @@ -0,0 +1,1218 @@ + + + + + + + + + + TEST_DATA_ITEM_RD1PF93 + TEST_DATA_ITEM_RDSZ2T0 + TEST_DATA_ITEM_RJXPZR3 + TEST_DATA_ITEM_RKYPJR5 + TEST_DATA_ITEM_RM7XHH8 + TEST_DATA_ITEM_RNXF8T7 + TEST_DATA_ITEM_RP5HKT7 + TEST_DATA_ITEM_RP7FX08 + TEST_DATA_ITEM_RPWYNV0 + TEST_DATA_ITEM_RRGSHJ7 + TEST_DATA_ITEM_RVG4979 + TEST_DATA_ITEM_RZFGN37 + TEST_DATA_ITEM_S03JPK3 + TEST_DATA_ITEM_S1HHY24 + TEST_DATA_ITEM_S1LQXM5 + TEST_DATA_ITEM_S2K1884 + TEST_DATA_ITEM_S2L0213 + TEST_DATA_ITEM_S2L11V1 + TEST_DATA_ITEM_S2L1YW8 + TEST_DATA_ITEM_S42MY19 + TEST_DATA_ITEM_S7P0Q34 + TEST_DATA_ITEM_S7P5H84 + TEST_DATA_ITEM_SBXZ9J5 + TEST_DATA_ITEM_SL59VF9 + TEST_DATA_ITEM_SNC4234 + TEST_DATA_ITEM_SSQFBD5 + TEST_DATA_ITEM_T5JZ7Y8 + TEST_DATA_ITEM_T68GVF0 + TEST_DATA_ITEM_T8B8C35 + TEST_DATA_ITEM_THX1KC6 + TEST_DATA_ITEM_TJHY616 + TEST_DATA_ITEM_TJJ1191 + TEST_DATA_ITEM_TM0R6S8 + TEST_DATA_ITEM_TSYCGY5 + TEST_DATA_ITEM_TX39352 + TEST_DATA_ITEM_TX3BMY5 + TEST_DATA_ITEM_TZ3YK09 + TEST_DATA_ITEM_TZNCGC5 + TEST_DATA_ITEM_V1KSJL0 + TEST_DATA_ITEM_V1L5YX7 + TEST_DATA_ITEM_VC83VJ8 + TEST_DATA_ITEM_VC9V9M0 + TEST_DATA_ITEM_VCZX9T3 + TEST_DATA_ITEM_VCZXR77 + TEST_DATA_ITEM_VDHL6L9 + TEST_DATA_ITEM_VFJRRL1 + TEST_DATA_ITEM_VGC9VR0 + TEST_DATA_ITEM_VHK1X95 + TEST_DATA_ITEM_VJHW0T6 + TEST_DATA_ITEM_VM3JV01 + TEST_DATA_ITEM_VPNFSD1 + TEST_DATA_ITEM_VQPPCY6 + TEST_DATA_ITEM_VR8SD78 + TEST_DATA_ITEM_VR8WDZ2 + TEST_DATA_ITEM_VSYYRR0 + TEST_DATA_ITEM_VT0SRW4 + TEST_DATA_ITEM_VVMW173 + TEST_DATA_ITEM_VVN62S5 + TEST_DATA_ITEM_VY1MTS3 + TEST_DATA_ITEM_W0JYML8 + TEST_DATA_ITEM_W0L8BB7 + TEST_DATA_ITEM_W0LMKN8 + TEST_DATA_ITEM_W0LPR69 + TEST_DATA_ITEM_W1PSL14 + TEST_DATA_ITEM_W28C167 + TEST_DATA_ITEM_W4MKVS5 + TEST_DATA_ITEM_W5FQPS6 + TEST_DATA_ITEM_W5FR5R0 + TEST_DATA_ITEM_W5FRCX8 + TEST_DATA_ITEM_W5FT8V7 + TEST_DATA_ITEM_W7G3Z50 + TEST_DATA_ITEM_W7W5NY8 + TEST_DATA_ITEM_W9LF131 + TEST_DATA_ITEM_W9M2XH8 + TEST_DATA_ITEM_W9MJ4N7 + TEST_DATA_ITEM_W9MJLJ4 + TEST_DATA_ITEM_WBPFZD3 + TEST_DATA_ITEM_WC7JCM9 + TEST_DATA_ITEM_WCNCWN6 + TEST_DATA_ITEM_WF4DL58 + TEST_DATA_ITEM_WFDDQN7 + TEST_DATA_ITEM_WFDQ5W9 + TEST_DATA_ITEM_WGHHQ80 + TEST_DATA_ITEM_WGHZBR2 + TEST_DATA_ITEM_WH4KZQ4 + TEST_DATA_ITEM_WH4MGH4 + TEST_DATA_ITEM_WHNLTJ3 + TEST_DATA_ITEM_WKGSRH3 + TEST_DATA_ITEM_WLP74S4 + TEST_DATA_ITEM_WMM5876 + TEST_DATA_ITEM_WPR8S02 + TEST_DATA_ITEM_WS568W8 + TEST_DATA_ITEM_WS5FLJ4 + TEST_DATA_ITEM_WVTFMN1 + TEST_DATA_ITEM_WXWG1T1 + TEST_DATA_ITEM_WXXM0P8 + TEST_DATA_ITEM_WXXTZW6 + TEST_DATA_ITEM_WXXVFD8 + TEST_DATA_ITEM_WYFYGR6 + TEST_DATA_ITEM_WYYG4G4 + TEST_DATA_ITEM_X26Y450 + TEST_DATA_ITEM_X28TQX2 + TEST_DATA_ITEM_X2VGW71 + TEST_DATA_ITEM_X4SX399 + TEST_DATA_ITEM_X5DC287 + TEST_DATA_ITEM_X5DCW09 + TEST_DATA_ITEM_X5FWXL7 + TEST_DATA_ITEM_X5FXHR5 + TEST_DATA_ITEM_X71SNK4 + TEST_DATA_ITEM_X7L19P5 + TEST_DATA_ITEM_X8SGGD0 + TEST_DATA_ITEM_X8SGHP5 + TEST_DATA_ITEM_XDJGZD2 + TEST_DATA_ITEM_XGCH665 + TEST_DATA_ITEM_XH5MMJ4 + TEST_DATA_ITEM_XH5SJJ5 + TEST_DATA_ITEM_XH5T078 + TEST_DATA_ITEM_XK36564 + TEST_DATA_ITEM_XK3WRP6 + TEST_DATA_ITEM_XMLRMW3 + TEST_DATA_ITEM_XMLSQ71 + TEST_DATA_ITEM_XMLV4R4 + TEST_DATA_ITEM_XMLW5H1 + TEST_DATA_ITEM_XP82TZ8 + TEST_DATA_ITEM_XP8Q7F2 + TEST_DATA_ITEM_XRJLX46 + TEST_DATA_ITEM_XRRQ5Y1 + TEST_DATA_ITEM_XRTFPT1 + TEST_DATA_ITEM_XRTJ094 + TEST_DATA_ITEM_XRTJ7G1 + TEST_DATA_ITEM_XS6R1W6 + TEST_DATA_ITEM_XS6SDV0 + TEST_DATA_ITEM_XT27V69 + TEST_DATA_ITEM_XT2CWY0 + TEST_DATA_ITEM_XTHQ679 + TEST_DATA_ITEM_XVBZ6C3 + TEST_DATA_ITEM_XWYLJZ4 + TEST_DATA_ITEM_XX9HGP0 + TEST_DATA_ITEM_XZQN201 + TEST_DATA_ITEM_Y04SBD7 + TEST_DATA_ITEM_Y1DFTW0 + TEST_DATA_ITEM_Y1TJTP9 + TEST_DATA_ITEM_Y29RBS9 + TEST_DATA_ITEM_Y2PX830 + TEST_DATA_ITEM_Y3M19V8 + TEST_DATA_ITEM_Y48N588 + TEST_DATA_ITEM_Y62WBN9 + TEST_DATA_ITEM_Y6G6NT5 + TEST_DATA_ITEM_Y73FBY3 + TEST_DATA_ITEM_Y73WNL2 + TEST_DATA_ITEM_Y7BR4D1 + TEST_DATA_ITEM_Y9DFXF2 + TEST_DATA_ITEM_Y9DLP26 + TEST_DATA_ITEM_Y9DNMM9 + TEST_DATA_ITEM_YBBLNL1 + TEST_DATA_ITEM_YD8K3L1 + TEST_DATA_ITEM_YD93FW9 + TEST_DATA_ITEM_YDGX7G6 + TEST_DATA_ITEM_YFGTVH5 + TEST_DATA_ITEM_YHYK1P0 + TEST_DATA_ITEM_YJKWWL1 + TEST_DATA_ITEM_YM42N63 + TEST_DATA_ITEM_YM46D25 + TEST_DATA_ITEM_YMWFTN5 + TEST_DATA_ITEM_YN8LKB2 + TEST_DATA_ITEM_YN8MVQ1 + TEST_DATA_ITEM_YNK8QZ1 + TEST_DATA_ITEM_YNK8VV4 + TEST_DATA_ITEM_YPSX189 + TEST_DATA_ITEM_YQ7XC99 + TEST_DATA_ITEM_YQ821Y7 + TEST_DATA_ITEM_YRHKZX2 + TEST_DATA_ITEM_YRJDQG5 + TEST_DATA_ITEM_YRJXFY7 + TEST_DATA_ITEM_YT4YFD0 + TEST_DATA_ITEM_YTS8ZC3 + TEST_DATA_ITEM_YTSD463 + TEST_DATA_ITEM_YTSSL78 + TEST_DATA_ITEM_YV1J506 + TEST_DATA_ITEM_YVWDX76 + TEST_DATA_ITEM_YYC3F04 + TEST_DATA_ITEM_YYCW069 + TEST_DATA_ITEM_YZ6J7F1 + TEST_DATA_ITEM_YZF4N35 + TEST_DATA_ITEM_YZF9M32 + TEST_DATA_ITEM_Z0FDB09 + TEST_DATA_ITEM_Z0GR9T6 + TEST_DATA_ITEM_Z0HPBH4 + TEST_DATA_ITEM_Z14GX93 + TEST_DATA_ITEM_Z1JKRH9 + TEST_DATA_ITEM_Z1JTC65 + TEST_DATA_ITEM_Z1JYD85 + TEST_DATA_ITEM_Z1SKF12 + TEST_DATA_ITEM_Z3VW193 + TEST_DATA_ITEM_Z3XTC80 + TEST_DATA_ITEM_Z40QKV0 + TEST_DATA_ITEM_Z5JKRL0 + TEST_DATA_ITEM_Z61T886 + TEST_DATA_ITEM_Z6F6PC7 + TEST_DATA_ITEM_Z6F7VR7 + TEST_DATA_ITEM_Z73NSG4 + TEST_DATA_ITEM_Z853026 + TEST_DATA_ITEM_Z8MRQ26 + TEST_DATA_ITEM_Z917FG2 + TEST_DATA_ITEM_Z9FKSV1 + TEST_DATA_ITEM_Z9FPZG7 + TEST_DATA_ITEM_ZF0FCL9 + TEST_DATA_ITEM_ZF3LDK5 + TEST_DATA_ITEM_ZGD6893 + TEST_DATA_ITEM_ZGF70F7 + TEST_DATA_ITEM_ZHDHTJ3 + TEST_DATA_ITEM_ZHSBLN8 + TEST_DATA_ITEM_ZJ0DR89 + TEST_DATA_ITEM_ZLHY3P0 + TEST_DATA_ITEM_ZLK1486 + TEST_DATA_ITEM_ZNLTB86 + TEST_DATA_ITEM_ZNR97S2 + TEST_DATA_ITEM_ZNSSHK5 + TEST_DATA_ITEM_ZR8BLY9 + TEST_DATA_ITEM_ZS44KX8 + TEST_DATA_ITEM_ZSDRY81 + TEST_DATA_ITEM_ZV0HS43 + TEST_DATA_ITEM_ZVN6KK4 + TEST_DATA_ITEM_ZVWZY77 + TEST_DATA_ITEM_ZVXJTK9 + TEST_DATA_ITEM_ZXQB4R8 + TEST_DATA_ITEM_ZXYXM97 + TEST_DATA_ITEM_100SH258 + TEST_DATA_ITEM_105XBR17 + TEST_DATA_ITEM_10FNXJ58 + TEST_DATA_ITEM_10JW9H28 + TEST_DATA_ITEM_10MVVTT6 + TEST_DATA_ITEM_10MVZF58 + TEST_DATA_ITEM_10WX4G55 + TEST_DATA_ITEM_10WX7YR9 + TEST_DATA_ITEM_1103B266 + TEST_DATA_ITEM_112Z58F7 + TEST_DATA_ITEM_1138D402 + TEST_DATA_ITEM_1163K2N1 + TEST_DATA_ITEM_116YM983 + TEST_DATA_ITEM_118JXC21 + TEST_DATA_ITEM_118LMWQ8 + TEST_DATA_ITEM_118Y8193 + TEST_DATA_ITEM_11BPJW25 + TEST_DATA_ITEM_11C0FQ08 + TEST_DATA_ITEM_11C0PBJ0 + TEST_DATA_ITEM_11C8DJL6 + TEST_DATA_ITEM_11FS2HK6 + TEST_DATA_ITEM_11J3GCN0 + TEST_DATA_ITEM_11K4VZM9 + TEST_DATA_ITEM_11M1TX41 + TEST_DATA_ITEM_11MGV9T1 + TEST_DATA_ITEM_11N542L7 + TEST_DATA_ITEM_11PCQVV1 + TEST_DATA_ITEM_11PFKDM0 + TEST_DATA_ITEM_11PSNRN7 + TEST_DATA_ITEM_11PTS335 + TEST_DATA_ITEM_11RH8527 + TEST_DATA_ITEM_11RK3G67 + TEST_DATA_ITEM_11RT3MR2 + TEST_DATA_ITEM_11RWTSM9 + TEST_DATA_ITEM_11XQL4N5 + TEST_DATA_ITEM_120TBYK1 + TEST_DATA_ITEM_120W16V4 + TEST_DATA_ITEM_12232039 + TEST_DATA_ITEM_122LQP47 + TEST_DATA_ITEM_122MC5Q0 + TEST_DATA_ITEM_123Q6TT2 + TEST_DATA_ITEM_1282Y9T3 + TEST_DATA_ITEM_1282ZJL8 + TEST_DATA_ITEM_129CWDS4 + TEST_DATA_ITEM_12BTZFT5 + TEST_DATA_ITEM_12BV9QP9 + TEST_DATA_ITEM_12C73NW6 + TEST_DATA_ITEM_12C7JPP2 + TEST_DATA_ITEM_12F6LZY6 + TEST_DATA_ITEM_12FCPQP9 + TEST_DATA_ITEM_12MBDC31 + TEST_DATA_ITEM_12MBFPV9 + TEST_DATA_ITEM_12PPWX76 + TEST_DATA_ITEM_12QFVS97 + TEST_DATA_ITEM_12QSDL49 + TEST_DATA_ITEM_12QVB1C9 + TEST_DATA_ITEM_12QX0K80 + TEST_DATA_ITEM_12R3SVM5 + TEST_DATA_ITEM_12THJBR1 + TEST_DATA_ITEM_12TKHH48 + TEST_DATA_ITEM_12V1MCV2 + TEST_DATA_ITEM_12V27BM9 + TEST_DATA_ITEM_12VBH621 + TEST_DATA_ITEM_12W99CF7 + TEST_DATA_ITEM_12WFRGG3 + TEST_DATA_ITEM_12Y71RB8 + TEST_DATA_ITEM_12YL4F48 + TEST_DATA_ITEM_134WCD50 + TEST_DATA_ITEM_135B2107 + TEST_DATA_ITEM_135W7XZ8 + TEST_DATA_ITEM_136KJJM5 + TEST_DATA_ITEM_13978WW3 + TEST_DATA_ITEM_139RY7J0 + TEST_DATA_ITEM_13CYT627 + TEST_DATA_ITEM_13GDWQH5 + TEST_DATA_ITEM_13KKBWZ4 + TEST_DATA_ITEM_13P11C13 + TEST_DATA_ITEM_13P1D8K8 + TEST_DATA_ITEM_13PL2VH9 + TEST_DATA_ITEM_13PRXVT9 + TEST_DATA_ITEM_13THLBR6 + TEST_DATA_ITEM_13ZGNYL5 + TEST_DATA_ITEM_145KKRP1 + TEST_DATA_ITEM_146YWG26 + TEST_DATA_ITEM_149QCWP2 + TEST_DATA_ITEM_14GJ8M40 + TEST_DATA_ITEM_14GJSJM5 + TEST_DATA_ITEM_14J211L8 + TEST_DATA_ITEM_14KFQZV4 + TEST_DATA_ITEM_14QJ4014 + TEST_DATA_ITEM_157C5S06 + TEST_DATA_ITEM_15H3RLY9 + TEST_DATA_ITEM_15LHYNV4 + TEST_DATA_ITEM_160DYBM0 + TEST_DATA_ITEM_16HRS1C1 + TEST_DATA_ITEM_1779WNW5 + TEST_DATA_ITEM_17BXPX26 + TEST_DATA_ITEM_17J18SJ0 + TEST_DATA_ITEM_17J1X165 + TEST_DATA_ITEM_17WSF072 + TEST_DATA_ITEM_17XFZWY7 + TEST_DATA_ITEM_19Y3V5C6 + TEST_DATA_ITEM_1B79XPY8 + + + + DATA.1 + + + DATA.2 + + + + + + + + TEST_DATA_ITEM_1K5SYM4 + TEST_DATA_ITEM_1K612R6 + TEST_DATA_ITEM_1K613S3 + TEST_DATA_ITEM_1K61W18 + TEST_DATA_ITEM_1K82SR4 + TEST_DATA_ITEM_1KS9432 + TEST_DATA_ITEM_1KWWRB7 + TEST_DATA_ITEM_1LH7712 + TEST_DATA_ITEM_1LWHLC5 + TEST_DATA_ITEM_1M6CZQ0 + TEST_DATA_ITEM_1MB89S0 + TEST_DATA_ITEM_1MC8Y67 + TEST_DATA_ITEM_1MKZGX8 + TEST_DATA_ITEM_1MMP7G4 + TEST_DATA_ITEM_1MP3370 + TEST_DATA_ITEM_1NBL4W0 + TEST_DATA_ITEM_1NDW105 + TEST_DATA_ITEM_1NFHCM9 + TEST_DATA_ITEM_1NY19C3 + TEST_DATA_ITEM_1P2KS92 + TEST_DATA_ITEM_1P6MYS7 + TEST_DATA_ITEM_1P71798 + TEST_DATA_ITEM_1PG5WP1 + TEST_DATA_ITEM_1PKMHX7 + TEST_DATA_ITEM_1PM3QY3 + TEST_DATA_ITEM_1Q7HP54 + TEST_DATA_ITEM_1QB7QN4 + TEST_DATA_ITEM_1QD41J3 + TEST_DATA_ITEM_1QJ1RF0 + TEST_DATA_ITEM_1QVVHP1 + TEST_DATA_ITEM_1QY89L3 + TEST_DATA_ITEM_1QYK8Q6 + TEST_DATA_ITEM_1QYNQV7 + TEST_DATA_ITEM_1R1GCP4 + TEST_DATA_ITEM_1R72SJ8 + TEST_DATA_ITEM_1RWPDP4 + TEST_DATA_ITEM_1S58GV7 + TEST_DATA_ITEM_1V6BP01 + TEST_DATA_ITEM_1VDB5Z2 + TEST_DATA_ITEM_1WMKH49 + TEST_DATA_ITEM_1WTB7Z2 + TEST_DATA_ITEM_1WWJKR7 + TEST_DATA_ITEM_1WWJTH9 + TEST_DATA_ITEM_1XJRKX9 + TEST_DATA_ITEM_1Y04TM7 + TEST_DATA_ITEM_1Y2XRZ1 + TEST_DATA_ITEM_1YH8PP1 + TEST_DATA_ITEM_1YKDN46 + TEST_DATA_ITEM_1YR4185 + TEST_DATA_ITEM_1YV1RR1 + TEST_DATA_ITEM_1Z5YJJ8 + TEST_DATA_ITEM_1ZM5R23 + TEST_DATA_ITEM_1ZR5V14 + TEST_DATA_ITEM_1ZZPJB0 + TEST_DATA_ITEM_2030MN4 + TEST_DATA_ITEM_209SZH9 + TEST_DATA_ITEM_212PVF7 + TEST_DATA_ITEM_21C31Z3 + TEST_DATA_ITEM_21H6XV3 + TEST_DATA_ITEM_21J73G1 + TEST_DATA_ITEM_21PB8C5 + TEST_DATA_ITEM_21PH401 + TEST_DATA_ITEM_21RGKR3 + TEST_DATA_ITEM_225ZCZ8 + TEST_DATA_ITEM_226DF92 + TEST_DATA_ITEM_2293PH6 + TEST_DATA_ITEM_22FDRM1 + TEST_DATA_ITEM_22MMM47 + TEST_DATA_ITEM_22PRZQ2 + TEST_DATA_ITEM_23XX752 + TEST_DATA_ITEM_2537T66 + TEST_DATA_ITEM_2583CR3 + TEST_DATA_ITEM_259NGW4 + TEST_DATA_ITEM_259SBC2 + TEST_DATA_ITEM_25DTRD6 + TEST_DATA_ITEM_25X1684 + TEST_DATA_ITEM_25XVR58 + TEST_DATA_ITEM_25Y4RX5 + TEST_DATA_ITEM_265J747 + TEST_DATA_ITEM_265J890 + TEST_DATA_ITEM_265K264 + TEST_DATA_ITEM_265T2Y4 + TEST_DATA_ITEM_265XT61 + TEST_DATA_ITEM_265Y0D5 + TEST_DATA_ITEM_265Y385 + TEST_DATA_ITEM_265Y3R4 + TEST_DATA_ITEM_265Y492 + TEST_DATA_ITEM_265Y4K9 + TEST_DATA_ITEM_27F2B70 + TEST_DATA_ITEM_27NTVR8 + TEST_DATA_ITEM_27Z6LY0 + TEST_DATA_ITEM_2832GJ2 + TEST_DATA_ITEM_283NM33 + TEST_DATA_ITEM_286RYD5 + TEST_DATA_ITEM_29SNNW3 + TEST_DATA_ITEM_29ZX804 + TEST_DATA_ITEM_2B04MD5 + TEST_DATA_ITEM_2BC7W26 + TEST_DATA_ITEM_2CHBLY8 + TEST_DATA_ITEM_2CN8XH2 + TEST_DATA_ITEM_2CV4Q65 + TEST_DATA_ITEM_2CV5W52 + TEST_DATA_ITEM_2G8Q1G2 + TEST_DATA_ITEM_2GBMZF5 + TEST_DATA_ITEM_2GKBN64 + TEST_DATA_ITEM_2H242T2 + TEST_DATA_ITEM_2N863Q1 + TEST_DATA_ITEM_2NC3XW2 + TEST_DATA_ITEM_2NCK5C6 + TEST_DATA_ITEM_2PY4KR5 + TEST_DATA_ITEM_2Q7DD08 + TEST_DATA_ITEM_2R1CW18 + TEST_DATA_ITEM_2R1JYX2 + TEST_DATA_ITEM_2TWLBK3 + TEST_DATA_ITEM_2V08ZP7 + TEST_DATA_ITEM_2V87RM2 + TEST_DATA_ITEM_2VNPMC1 + TEST_DATA_ITEM_2VZ68D5 + TEST_DATA_ITEM_2WLDMR1 + TEST_DATA_ITEM_2WN7DS3 + TEST_DATA_ITEM_2Y9YZ03 + TEST_DATA_ITEM_2YSBH33 + TEST_DATA_ITEM_2ZCK2F7 + TEST_DATA_ITEM_2ZHMDC3 + TEST_DATA_ITEM_2ZYMKP6 + TEST_DATA_ITEM_328Q6M7 + TEST_DATA_ITEM_331G2L2 + TEST_DATA_ITEM_3338H16 + TEST_DATA_ITEM_34VYL97 + TEST_DATA_ITEM_35LY8V2 + TEST_DATA_ITEM_38J7Q35 + TEST_DATA_ITEM_39320K2 + TEST_DATA_ITEM_393H570 + TEST_DATA_ITEM_3981NR5 + TEST_DATA_ITEM_3BC3JN4 + TEST_DATA_ITEM_3BW05J8 + TEST_DATA_ITEM_3CSG3N9 + TEST_DATA_ITEM_3CVJNM6 + TEST_DATA_ITEM_3CVMLJ0 + TEST_DATA_ITEM_3D4V915 + TEST_DATA_ITEM_3DNHV47 + TEST_DATA_ITEM_3FD3647 + TEST_DATA_ITEM_3GMH2C1 + TEST_DATA_ITEM_3LF0QF2 + TEST_DATA_ITEM_3LFWLS4 + TEST_DATA_ITEM_3M6RTM8 + TEST_DATA_ITEM_3MKSKY2 + TEST_DATA_ITEM_3MSMCM2 + TEST_DATA_ITEM_3NJHZK8 + TEST_DATA_ITEM_3NXJMR7 + TEST_DATA_ITEM_3PHHZR3 + TEST_DATA_ITEM_3PS7JG8 + TEST_DATA_ITEM_3Q5HK19 + TEST_DATA_ITEM_3RY8199 + TEST_DATA_ITEM_3S43W19 + TEST_DATA_ITEM_3T1GLD1 + TEST_DATA_ITEM_3TCRP91 + TEST_DATA_ITEM_42V6B90 + TEST_DATA_ITEM_42V8KB5 + TEST_DATA_ITEM_4332MG3 + TEST_DATA_ITEM_4336Q52 + TEST_DATA_ITEM_43BYP46 + TEST_DATA_ITEM_443M531 + TEST_DATA_ITEM_44BWGM7 + TEST_DATA_ITEM_44JTND9 + TEST_DATA_ITEM_44K5CS0 + TEST_DATA_ITEM_46L1KK0 + TEST_DATA_ITEM_46M36P2 + TEST_DATA_ITEM_47C19F0 + TEST_DATA_ITEM_4CYX1J4 + TEST_DATA_ITEM_4DRTM89 + TEST_DATA_ITEM_4FPDKG3 + TEST_DATA_ITEM_4HK6T53 + TEST_DATA_ITEM_4HQHKF6 + TEST_DATA_ITEM_4HTLQ62 + TEST_DATA_ITEM_4HTMCD4 + TEST_DATA_ITEM_4HTNF91 + TEST_DATA_ITEM_4K27NX0 + TEST_DATA_ITEM_4KB3S09 + TEST_DATA_ITEM_4KDF0Z5 + TEST_DATA_ITEM_4LT48C9 + TEST_DATA_ITEM_4M8M6F5 + TEST_DATA_ITEM_4M9ZHB9 + TEST_DATA_ITEM_4MB8147 + TEST_DATA_ITEM_4MF59G1 + TEST_DATA_ITEM_4MN1R23 + TEST_DATA_ITEM_4NLQDL9 + TEST_DATA_ITEM_4P33P44 + TEST_DATA_ITEM_4PKT0F1 + TEST_DATA_ITEM_4PW84C3 + TEST_DATA_ITEM_4Q00KR8 + TEST_DATA_ITEM_4S69ZV6 + TEST_DATA_ITEM_4SCBZS4 + TEST_DATA_ITEM_4SK5VK0 + TEST_DATA_ITEM_4SLD8Y5 + TEST_DATA_ITEM_4TYNXJ7 + TEST_DATA_ITEM_4WQKBX5 + TEST_DATA_ITEM_4X2QSY3 + TEST_DATA_ITEM_4Z1PVR5 + TEST_DATA_ITEM_53Z92J3 + TEST_DATA_ITEM_5497GX5 + TEST_DATA_ITEM_5544NR0 + TEST_DATA_ITEM_55FJVD6 + TEST_DATA_ITEM_56655N6 + TEST_DATA_ITEM_56JW5F7 + TEST_DATA_ITEM_57SDZW2 + TEST_DATA_ITEM_58KMGM1 + TEST_DATA_ITEM_5914G24 + TEST_DATA_ITEM_59FN6V2 + TEST_DATA_ITEM_5BLN156 + TEST_DATA_ITEM_5BTNF94 + TEST_DATA_ITEM_5C9FQB9 + TEST_DATA_ITEM_5CHLM23 + TEST_DATA_ITEM_5CHSS23 + TEST_DATA_ITEM_5CX4HJ0 + TEST_DATA_ITEM_5D1Y4M1 + TEST_DATA_ITEM_5D7PD75 + TEST_DATA_ITEM_5D7QCC0 + TEST_DATA_ITEM_5DJFD34 + TEST_DATA_ITEM_5DWN8J0 + TEST_DATA_ITEM_5H82FL3 + TEST_DATA_ITEM_5HTCSZ3 + TEST_DATA_ITEM_5KC3JN9 + TEST_DATA_ITEM_5KC4Z34 + TEST_DATA_ITEM_5L86FY0 + TEST_DATA_ITEM_5M4HFS3 + TEST_DATA_ITEM_5MX5GQ2 + TEST_DATA_ITEM_5NTTSH8 + TEST_DATA_ITEM_5P33368 + TEST_DATA_ITEM_5PG80F0 + TEST_DATA_ITEM_5PXTR52 + TEST_DATA_ITEM_5Q22H32 + TEST_DATA_ITEM_5Q29TT1 + TEST_DATA_ITEM_5Q3MQ74 + TEST_DATA_ITEM_5RVGYZ0 + TEST_DATA_ITEM_5S5X7T3 + TEST_DATA_ITEM_5T10SB0 + TEST_DATA_ITEM_5T5RWP8 + TEST_DATA_ITEM_5TJKDX8 + TEST_DATA_ITEM_5TNRYD8 + TEST_DATA_ITEM_5WQVSV5 + TEST_DATA_ITEM_5WX31J4 + TEST_DATA_ITEM_5WX3GZ3 + TEST_DATA_ITEM_5XKG704 + TEST_DATA_ITEM_5XNT5S8 + TEST_DATA_ITEM_5XR47G5 + TEST_DATA_ITEM_5XVML57 + TEST_DATA_ITEM_5XVXMD4 + TEST_DATA_ITEM_5XZHQZ0 + TEST_DATA_ITEM_5ZP9905 + TEST_DATA_ITEM_5ZRM1T2 + TEST_DATA_ITEM_5ZV19Y3 + TEST_DATA_ITEM_5ZVD8W4 + TEST_DATA_ITEM_5ZVK9M5 + TEST_DATA_ITEM_60B3LG4 + TEST_DATA_ITEM_60CNMF9 + TEST_DATA_ITEM_629NGG6 + TEST_DATA_ITEM_63GCHD2 + TEST_DATA_ITEM_63N8V50 + TEST_DATA_ITEM_6473QV1 + TEST_DATA_ITEM_64N0ZY6 + TEST_DATA_ITEM_64N2T69 + TEST_DATA_ITEM_658F3L7 + TEST_DATA_ITEM_65B28F0 + TEST_DATA_ITEM_66FZJL3 + TEST_DATA_ITEM_67QVJ32 + TEST_DATA_ITEM_6BFYQM1 + TEST_DATA_ITEM_6BZHZ28 + TEST_DATA_ITEM_6D97TY4 + TEST_DATA_ITEM_6DZTHY8 + TEST_DATA_ITEM_6F8QZF0 + TEST_DATA_ITEM_6FC9ZZ8 + TEST_DATA_ITEM_6GNRZ10 + TEST_DATA_ITEM_6HFPX68 + TEST_DATA_ITEM_6JS5776 + TEST_DATA_ITEM_6KDCG60 + TEST_DATA_ITEM_6KZRJY8 + TEST_DATA_ITEM_6MC4LM0 + TEST_DATA_ITEM_6MDLXX1 + TEST_DATA_ITEM_6N7S1J2 + TEST_DATA_ITEM_6NM92T7 + TEST_DATA_ITEM_6NSMRN0 + TEST_DATA_ITEM_6Q4JR45 + TEST_DATA_ITEM_6Q52QT5 + TEST_DATA_ITEM_6R5SRB3 + TEST_DATA_ITEM_6RB1XG1 + TEST_DATA_ITEM_6S59GX3 + TEST_DATA_ITEM_6SCVC71 + TEST_DATA_ITEM_6XWWBK7 + TEST_DATA_ITEM_6YWVSN7 + TEST_DATA_ITEM_6Z564Q3 + TEST_DATA_ITEM_70J7ZY0 + TEST_DATA_ITEM_71HZ630 + TEST_DATA_ITEM_7318RQ2 + TEST_DATA_ITEM_73F9RP1 + TEST_DATA_ITEM_74JPBL3 + TEST_DATA_ITEM_74Q3NJ8 + TEST_DATA_ITEM_74VSJH1 + TEST_DATA_ITEM_77Q6Q50 + TEST_DATA_ITEM_77VNXK8 + TEST_DATA_ITEM_77VS187 + TEST_DATA_ITEM_78W3N65 + TEST_DATA_ITEM_78Y1D74 + TEST_DATA_ITEM_79T1K69 + TEST_DATA_ITEM_7BVZ8G0 + TEST_DATA_ITEM_7DHG843 + TEST_DATA_ITEM_7DHXQL5 + TEST_DATA_ITEM_7FG09F6 + TEST_DATA_ITEM_7FH8JR1 + TEST_DATA_ITEM_7H0TDD1 + TEST_DATA_ITEM_7HRJX03 + TEST_DATA_ITEM_7HWGTZ6 + TEST_DATA_ITEM_7J2XLR7 + TEST_DATA_ITEM_7KC7NM3 + TEST_DATA_ITEM_7KGRPK9 + TEST_DATA_ITEM_7NJLS20 + TEST_DATA_ITEM_7NLG3D4 + TEST_DATA_ITEM_7NM37N6 + TEST_DATA_ITEM_7NSWGH8 + TEST_DATA_ITEM_7QZBG64 + TEST_DATA_ITEM_7SV91S3 + TEST_DATA_ITEM_7T9DYL1 + TEST_DATA_ITEM_7TJF1M8 + TEST_DATA_ITEM_7W9BP38 + TEST_DATA_ITEM_7WX14V2 + TEST_DATA_ITEM_7Z9TCY1 + TEST_DATA_ITEM_81VHT64 + TEST_DATA_ITEM_829DZ71 + TEST_DATA_ITEM_8417VM5 + TEST_DATA_ITEM_87F73K5 + TEST_DATA_ITEM_8974324 + TEST_DATA_ITEM_8B2CXR0 + TEST_DATA_ITEM_8B7FKG6 + TEST_DATA_ITEM_8CS2P27 + TEST_DATA_ITEM_8G28L69 + TEST_DATA_ITEM_8G5ZX75 + TEST_DATA_ITEM_8HNK0Q2 + TEST_DATA_ITEM_8HNZ816 + TEST_DATA_ITEM_8N1BXX3 + TEST_DATA_ITEM_8N1HWF9 + TEST_DATA_ITEM_8N29887 + TEST_DATA_ITEM_8NMBXM9 + TEST_DATA_ITEM_8NZ8PY8 + TEST_DATA_ITEM_8P7F832 + TEST_DATA_ITEM_8QPZ964 + TEST_DATA_ITEM_98VP8P1 + TEST_DATA_ITEM_99X6840 + TEST_DATA_ITEM_9DFHW85 + TEST_DATA_ITEM_9DMF643 + TEST_DATA_ITEM_9DVZS89 + TEST_DATA_ITEM_9F3H5C4 + TEST_DATA_ITEM_9H06RN0 + TEST_DATA_ITEM_9H33P42 + TEST_DATA_ITEM_9HYYCC0 + TEST_DATA_ITEM_9J8K5H0 + TEST_DATA_ITEM_9KD84C9 + TEST_DATA_ITEM_9KG16X1 + TEST_DATA_ITEM_9L0WFF1 + TEST_DATA_ITEM_9LR89M5 + TEST_DATA_ITEM_9LVKPB8 + TEST_DATA_ITEM_9NMSGF4 + TEST_DATA_ITEM_9PHHNW1 + TEST_DATA_ITEM_9PN0BZ9 + TEST_DATA_ITEM_9Q03659 + TEST_DATA_ITEM_9R0CT30 + TEST_DATA_ITEM_9R48CV3 + TEST_DATA_ITEM_9S1XNF4 + TEST_DATA_ITEM_9SYBY62 + TEST_DATA_ITEM_9T0TKT1 + TEST_DATA_ITEM_9T223N0 + TEST_DATA_ITEM_9W8YNM5 + TEST_DATA_ITEM_9XW2W00 + TEST_DATA_ITEM_B3T3GZ1 + TEST_DATA_ITEM_B5ZT2C3 + TEST_DATA_ITEM_B6F29Z5 + TEST_DATA_ITEM_B6G8059 + TEST_DATA_ITEM_B6QMZR0 + TEST_DATA_ITEM_B9N3KX1 + TEST_DATA_ITEM_BC58RL9 + TEST_DATA_ITEM_BCHPRL4 + TEST_DATA_ITEM_BCQJ2N4 + TEST_DATA_ITEM_BDCCTY0 + TEST_DATA_ITEM_BFHD177 + TEST_DATA_ITEM_BFHD6J3 + TEST_DATA_ITEM_BFHDCL7 + TEST_DATA_ITEM_BLVZ1W7 + TEST_DATA_ITEM_BLYKRY8 + TEST_DATA_ITEM_BM5XVM0 + TEST_DATA_ITEM_BN8S8L1 + TEST_DATA_ITEM_BN96557 + TEST_DATA_ITEM_BN965M8 + TEST_DATA_ITEM_BNTV528 + TEST_DATA_ITEM_BR9Q533 + TEST_DATA_ITEM_BS050G1 + TEST_DATA_ITEM_BTJVJN1 + TEST_DATA_ITEM_BV2Y8C8 + TEST_DATA_ITEM_BVR0CS4 + TEST_DATA_ITEM_C0NV622 + TEST_DATA_ITEM_C1BZMM6 + TEST_DATA_ITEM_C4DL550 + TEST_DATA_ITEM_C764D45 + TEST_DATA_ITEM_C77LF85 + TEST_DATA_ITEM_CBYY6J5 + TEST_DATA_ITEM_CCNTJ06 + TEST_DATA_ITEM_CP9PCB0 + TEST_DATA_ITEM_CSDQMB5 + TEST_DATA_ITEM_CSG01S4 + TEST_DATA_ITEM_CTNNT93 + TEST_DATA_ITEM_CTZ4C49 + TEST_DATA_ITEM_CVQYJN7 + TEST_DATA_ITEM_CW0SNV2 + TEST_DATA_ITEM_CW88RB0 + TEST_DATA_ITEM_CWTTPF1 + TEST_DATA_ITEM_CZNLQX7 + TEST_DATA_ITEM_D0Y8150 + TEST_DATA_ITEM_D0YK7S8 + TEST_DATA_ITEM_D2Z7X38 + TEST_DATA_ITEM_D30HGG6 + TEST_DATA_ITEM_D36Q0Y8 + TEST_DATA_ITEM_D5L3SQ6 + TEST_DATA_ITEM_D854W79 + TEST_DATA_ITEM_D88BWN7 + TEST_DATA_ITEM_D8JC855 + TEST_DATA_ITEM_NN874Q2 + TEST_DATA_ITEM_NN9HMZ9 + TEST_DATA_ITEM_NNW8CC5 + TEST_DATA_ITEM_NSBBST9 + TEST_DATA_ITEM_NSGPHL5 + TEST_DATA_ITEM_NTM77W1 + TEST_DATA_ITEM_NTMFCY9 + TEST_DATA_ITEM_NWCBRS5 + TEST_DATA_ITEM_NWR7XX8 + TEST_DATA_ITEM_NX1ZL23 + TEST_DATA_ITEM_P0YVWW9 + TEST_DATA_ITEM_P2HLM57 + TEST_DATA_ITEM_P33TC79 + TEST_DATA_ITEM_P4JBS77 + TEST_DATA_ITEM_P4R2RX2 + TEST_DATA_ITEM_P4V6488 + TEST_DATA_ITEM_P5B2Q95 + TEST_DATA_ITEM_P80SD42 + TEST_DATA_ITEM_P99J4F0 + TEST_DATA_ITEM_P9KDGX4 + TEST_DATA_ITEM_P9KHS64 + TEST_DATA_ITEM_PBD6TY6 + TEST_DATA_ITEM_PDYP436 + TEST_DATA_ITEM_PF4SSD3 + TEST_DATA_ITEM_PFB4QJ1 + TEST_DATA_ITEM_PGH1GH4 + TEST_DATA_ITEM_PGK4SL3 + TEST_DATA_ITEM_PKCBY08 + TEST_DATA_ITEM_PKGL404 + TEST_DATA_ITEM_PLQ0S01 + TEST_DATA_ITEM_PM24Z12 + TEST_DATA_ITEM_PM256H8 + TEST_DATA_ITEM_PM8N596 + TEST_DATA_ITEM_PNFCVP6 + TEST_DATA_ITEM_PNN7288 + TEST_DATA_ITEM_PNR0WT7 + TEST_DATA_ITEM_PPP6FW6 + TEST_DATA_ITEM_PPXGG29 + TEST_DATA_ITEM_PQ4XFB5 + TEST_DATA_ITEM_PQGXHY9 + TEST_DATA_ITEM_PQRZX14 + TEST_DATA_ITEM_PT33734 + TEST_DATA_ITEM_PZV44X8 + TEST_DATA_ITEM_Q011TH6 + TEST_DATA_ITEM_Q3HY9H6 + TEST_DATA_ITEM_Q70LZG6 + TEST_DATA_ITEM_Q72WX48 + TEST_DATA_ITEM_Q8J3R18 + TEST_DATA_ITEM_QDCHBL5 + TEST_DATA_ITEM_QFW4LT3 + TEST_DATA_ITEM_QG40R60 + TEST_DATA_ITEM_QHJM2M9 + TEST_DATA_ITEM_QHK2C82 + TEST_DATA_ITEM_QJ46QB7 + TEST_DATA_ITEM_QJBWHP7 + TEST_DATA_ITEM_QLF1CR8 + TEST_DATA_ITEM_QN8JZX5 + TEST_DATA_ITEM_QQ1XHZ9 + TEST_DATA_ITEM_QQ8C6S9 + TEST_DATA_ITEM_QQ8GRH1 + TEST_DATA_ITEM_QS5PBQ0 + TEST_DATA_ITEM_QV3CB85 + TEST_DATA_ITEM_QVJV494 + TEST_DATA_ITEM_QYLY9P4 + TEST_DATA_ITEM_QYNLWF4 + TEST_DATA_ITEM_R1WNZS5 + TEST_DATA_ITEM_R24W7H0 + TEST_DATA_ITEM_R28WT29 + TEST_DATA_ITEM_R2JZFV0 + TEST_DATA_ITEM_R2K8TC8 + TEST_DATA_ITEM_R4SGV71 + TEST_DATA_ITEM_R7TJRF3 + TEST_DATA_ITEM_RB9B6Y5 + TEST_DATA_ITEM_RBF97K7 + TEST_DATA_ITEM_RBFBJD6 + TEST_DATA_ITEM_RCNNPK3 + TEST_DATA_ITEM_RCQD6F5 + TEST_DATA_ITEM_RD1PF93 + TEST_DATA_ITEM_RDSZ2T0 + TEST_DATA_ITEM_RJXPZR3 + TEST_DATA_ITEM_RKYPJR5 + TEST_DATA_ITEM_RM7XHH8 + TEST_DATA_ITEM_RNXF8T7 + TEST_DATA_ITEM_RP5HKT7 + TEST_DATA_ITEM_RP7FX08 + TEST_DATA_ITEM_RPWYNV0 + TEST_DATA_ITEM_RRGSHJ7 + TEST_DATA_ITEM_RVG4979 + TEST_DATA_ITEM_RZFGN37 + TEST_DATA_ITEM_S03JPK3 + TEST_DATA_ITEM_S1HHY24 + TEST_DATA_ITEM_S1LQXM5 + TEST_DATA_ITEM_S2K1884 + TEST_DATA_ITEM_S2L0213 + TEST_DATA_ITEM_S2L11V1 + TEST_DATA_ITEM_S2L1YW8 + TEST_DATA_ITEM_S42MY19 + TEST_DATA_ITEM_S7P0Q34 + TEST_DATA_ITEM_S7P5H84 + TEST_DATA_ITEM_SBXZ9J5 + TEST_DATA_ITEM_SL59VF9 + TEST_DATA_ITEM_SNC4234 + TEST_DATA_ITEM_SSQFBD5 + TEST_DATA_ITEM_T5JZ7Y8 + TEST_DATA_ITEM_T68GVF0 + TEST_DATA_ITEM_T8B8C35 + TEST_DATA_ITEM_THX1KC6 + TEST_DATA_ITEM_TJHY616 + TEST_DATA_ITEM_TJJ1191 + TEST_DATA_ITEM_TM0R6S8 + TEST_DATA_ITEM_TSYCGY5 + TEST_DATA_ITEM_TX39352 + TEST_DATA_ITEM_TX3BMY5 + TEST_DATA_ITEM_TZ3YK09 + TEST_DATA_ITEM_TZNCGC5 + TEST_DATA_ITEM_V1KSJL0 + TEST_DATA_ITEM_V1L5YX7 + TEST_DATA_ITEM_VC83VJ8 + TEST_DATA_ITEM_VC9V9M0 + TEST_DATA_ITEM_VCZX9T3 + TEST_DATA_ITEM_VCZXR77 + TEST_DATA_ITEM_VDHL6L9 + TEST_DATA_ITEM_VFJRRL1 + TEST_DATA_ITEM_VGC9VR0 + TEST_DATA_ITEM_VHK1X95 + TEST_DATA_ITEM_VJHW0T6 + TEST_DATA_ITEM_VM3JV01 + TEST_DATA_ITEM_VPNFSD1 + TEST_DATA_ITEM_VQPPCY6 + TEST_DATA_ITEM_VR8SD78 + TEST_DATA_ITEM_VR8WDZ2 + TEST_DATA_ITEM_VSYYRR0 + TEST_DATA_ITEM_VT0SRW4 + TEST_DATA_ITEM_VVMW173 + TEST_DATA_ITEM_VVN62S5 + TEST_DATA_ITEM_VY1MTS3 + TEST_DATA_ITEM_W0JYML8 + TEST_DATA_ITEM_W0L8BB7 + TEST_DATA_ITEM_W0LMKN8 + TEST_DATA_ITEM_W0LPR69 + TEST_DATA_ITEM_W1PSL14 + TEST_DATA_ITEM_W28C167 + TEST_DATA_ITEM_W4MKVS5 + TEST_DATA_ITEM_W5FQPS6 + TEST_DATA_ITEM_W5FR5R0 + TEST_DATA_ITEM_W5FRCX8 + TEST_DATA_ITEM_W5FT8V7 + TEST_DATA_ITEM_W7G3Z50 + TEST_DATA_ITEM_W7W5NY8 + TEST_DATA_ITEM_W9LF131 + TEST_DATA_ITEM_W9M2XH8 + TEST_DATA_ITEM_W9MJ4N7 + TEST_DATA_ITEM_W9MJLJ4 + TEST_DATA_ITEM_WBPFZD3 + TEST_DATA_ITEM_WC7JCM9 + TEST_DATA_ITEM_WCNCWN6 + TEST_DATA_ITEM_WF4DL58 + TEST_DATA_ITEM_WFDDQN7 + TEST_DATA_ITEM_WFDQ5W9 + TEST_DATA_ITEM_WGHHQ80 + TEST_DATA_ITEM_WGHZBR2 + TEST_DATA_ITEM_WH4KZQ4 + TEST_DATA_ITEM_WH4MGH4 + TEST_DATA_ITEM_WHNLTJ3 + TEST_DATA_ITEM_WKGSRH3 + TEST_DATA_ITEM_WLP74S4 + TEST_DATA_ITEM_WMM5876 + TEST_DATA_ITEM_WPR8S02 + TEST_DATA_ITEM_WS568W8 + TEST_DATA_ITEM_WS5FLJ4 + TEST_DATA_ITEM_WVTFMN1 + TEST_DATA_ITEM_WXWG1T1 + TEST_DATA_ITEM_WXXM0P8 + TEST_DATA_ITEM_WXXTZW6 + TEST_DATA_ITEM_WXXVFD8 + TEST_DATA_ITEM_WYFYGR6 + TEST_DATA_ITEM_WYYG4G4 + TEST_DATA_ITEM_X26Y450 + TEST_DATA_ITEM_X28TQX2 + TEST_DATA_ITEM_X2VGW71 + TEST_DATA_ITEM_X4SX399 + TEST_DATA_ITEM_X5DC287 + TEST_DATA_ITEM_X5DCW09 + TEST_DATA_ITEM_X5FWXL7 + TEST_DATA_ITEM_X5FXHR5 + TEST_DATA_ITEM_X71SNK4 + TEST_DATA_ITEM_X7L19P5 + TEST_DATA_ITEM_X8SGGD0 + TEST_DATA_ITEM_X8SGHP5 + TEST_DATA_ITEM_XDJGZD2 + TEST_DATA_ITEM_XGCH665 + TEST_DATA_ITEM_XH5MMJ4 + TEST_DATA_ITEM_XH5SJJ5 + TEST_DATA_ITEM_XH5T078 + TEST_DATA_ITEM_XK36564 + TEST_DATA_ITEM_XK3WRP6 + TEST_DATA_ITEM_XMLRMW3 + TEST_DATA_ITEM_XMLSQ71 + TEST_DATA_ITEM_XMLV4R4 + TEST_DATA_ITEM_XMLW5H1 + TEST_DATA_ITEM_XP82TZ8 + TEST_DATA_ITEM_XP8Q7F2 + TEST_DATA_ITEM_XRJLX46 + TEST_DATA_ITEM_XRRQ5Y1 + TEST_DATA_ITEM_XRTFPT1 + TEST_DATA_ITEM_XRTJ094 + TEST_DATA_ITEM_XRTJ7G1 + TEST_DATA_ITEM_XS6R1W6 + TEST_DATA_ITEM_XS6SDV0 + TEST_DATA_ITEM_XT27V69 + TEST_DATA_ITEM_XT2CWY0 + TEST_DATA_ITEM_XTHQ679 + TEST_DATA_ITEM_XVBZ6C3 + TEST_DATA_ITEM_XWYLJZ4 + TEST_DATA_ITEM_XX9HGP0 + TEST_DATA_ITEM_XZQN201 + TEST_DATA_ITEM_Y04SBD7 + TEST_DATA_ITEM_Y1DFTW0 + TEST_DATA_ITEM_Y1TJTP9 + TEST_DATA_ITEM_Y29RBS9 + TEST_DATA_ITEM_Y2PX830 + TEST_DATA_ITEM_Y3M19V8 + TEST_DATA_ITEM_Y48N588 + TEST_DATA_ITEM_Y62WBN9 + TEST_DATA_ITEM_Y6G6NT5 + TEST_DATA_ITEM_Y73FBY3 + TEST_DATA_ITEM_Y73WNL2 + TEST_DATA_ITEM_Y7BR4D1 + TEST_DATA_ITEM_Y9DFXF2 + TEST_DATA_ITEM_Y9DLP26 + TEST_DATA_ITEM_Y9DNMM9 + TEST_DATA_ITEM_YBBLNL1 + TEST_DATA_ITEM_YD8K3L1 + TEST_DATA_ITEM_YD93FW9 + TEST_DATA_ITEM_YDGX7G6 + TEST_DATA_ITEM_YFGTVH5 + TEST_DATA_ITEM_YHYK1P0 + TEST_DATA_ITEM_YJKWWL1 + TEST_DATA_ITEM_YM42N63 + TEST_DATA_ITEM_YM46D25 + TEST_DATA_ITEM_YMWFTN5 + TEST_DATA_ITEM_YN8LKB2 + TEST_DATA_ITEM_YN8MVQ1 + TEST_DATA_ITEM_YNK8QZ1 + TEST_DATA_ITEM_YNK8VV4 + TEST_DATA_ITEM_YPSX189 + TEST_DATA_ITEM_YQ7XC99 + TEST_DATA_ITEM_YQ821Y7 + TEST_DATA_ITEM_YRHKZX2 + TEST_DATA_ITEM_YRJDQG5 + TEST_DATA_ITEM_YRJXFY7 + TEST_DATA_ITEM_YT4YFD0 + TEST_DATA_ITEM_YTS8ZC3 + TEST_DATA_ITEM_YTSD463 + TEST_DATA_ITEM_YTSSL78 + TEST_DATA_ITEM_YV1J506 + TEST_DATA_ITEM_YVWDX76 + TEST_DATA_ITEM_YYC3F04 + TEST_DATA_ITEM_YYCW069 + TEST_DATA_ITEM_YZ6J7F1 + TEST_DATA_ITEM_YZF4N35 + TEST_DATA_ITEM_YZF9M32 + TEST_DATA_ITEM_Z0FDB09 + TEST_DATA_ITEM_Z0GR9T6 + TEST_DATA_ITEM_Z0HPBH4 + TEST_DATA_ITEM_Z14GX93 + TEST_DATA_ITEM_Z1JKRH9 + TEST_DATA_ITEM_Z1JTC65 + TEST_DATA_ITEM_Z1JYD85 + TEST_DATA_ITEM_Z1SKF12 + TEST_DATA_ITEM_Z3VW193 + TEST_DATA_ITEM_Z3XTC80 + TEST_DATA_ITEM_Z40QKV0 + TEST_DATA_ITEM_Z5JKRL0 + TEST_DATA_ITEM_Z61T886 + TEST_DATA_ITEM_Z6F6PC7 + TEST_DATA_ITEM_Z6F7VR7 + TEST_DATA_ITEM_Z73NSG4 + TEST_DATA_ITEM_Z853026 + TEST_DATA_ITEM_Z8MRQ26 + TEST_DATA_ITEM_Z917FG2 + TEST_DATA_ITEM_Z9FKSV1 + TEST_DATA_ITEM_Z9FPZG7 + TEST_DATA_ITEM_ZF0FCL9 + TEST_DATA_ITEM_ZF3LDK5 + TEST_DATA_ITEM_ZGD6893 + TEST_DATA_ITEM_ZGF70F7 + TEST_DATA_ITEM_ZHDHTJ3 + TEST_DATA_ITEM_ZHSBLN8 + TEST_DATA_ITEM_ZJ0DR89 + TEST_DATA_ITEM_ZLHY3P0 + TEST_DATA_ITEM_ZLK1486 + TEST_DATA_ITEM_ZNLTB86 + TEST_DATA_ITEM_ZNR97S2 + TEST_DATA_ITEM_ZNSSHK5 + TEST_DATA_ITEM_ZR8BLY9 + TEST_DATA_ITEM_ZS44KX8 + TEST_DATA_ITEM_ZSDRY81 + TEST_DATA_ITEM_ZV0HS43 + TEST_DATA_ITEM_ZVN6KK4 + TEST_DATA_ITEM_ZVWZY77 + TEST_DATA_ITEM_ZVXJTK9 + TEST_DATA_ITEM_ZXQB4R8 + TEST_DATA_ITEM_ZXYXM97 + TEST_DATA_ITEM_100SH258 + TEST_DATA_ITEM_105XBR17 + TEST_DATA_ITEM_10FNXJ58 + TEST_DATA_ITEM_10JW9H28 + TEST_DATA_ITEM_10MVVTT6 + TEST_DATA_ITEM_10MVZF58 + TEST_DATA_ITEM_10WX4G55 + TEST_DATA_ITEM_10WX7YR9 + TEST_DATA_ITEM_1103B266 + TEST_DATA_ITEM_112Z58F7 + TEST_DATA_ITEM_1138D402 + TEST_DATA_ITEM_1163K2N1 + TEST_DATA_ITEM_116YM983 + TEST_DATA_ITEM_118JXC21 + TEST_DATA_ITEM_118LMWQ8 + TEST_DATA_ITEM_118Y8193 + TEST_DATA_ITEM_11BPJW25 + TEST_DATA_ITEM_11C0FQ08 + TEST_DATA_ITEM_11C0PBJ0 + TEST_DATA_ITEM_11C8DJL6 + TEST_DATA_ITEM_11FS2HK6 + TEST_DATA_ITEM_11J3GCN0 + TEST_DATA_ITEM_11K4VZM9 + TEST_DATA_ITEM_11M1TX41 + TEST_DATA_ITEM_11MGV9T1 + TEST_DATA_ITEM_11N542L7 + TEST_DATA_ITEM_11PCQVV1 + TEST_DATA_ITEM_11PFKDM0 + TEST_DATA_ITEM_11PSNRN7 + TEST_DATA_ITEM_11PTS335 + TEST_DATA_ITEM_11RH8527 + TEST_DATA_ITEM_11RK3G67 + TEST_DATA_ITEM_11RT3MR2 + TEST_DATA_ITEM_11RWTSM9 + TEST_DATA_ITEM_11XQL4N5 + TEST_DATA_ITEM_120TBYK1 + TEST_DATA_ITEM_120W16V4 + TEST_DATA_ITEM_12232039 + TEST_DATA_ITEM_122LQP47 + TEST_DATA_ITEM_122MC5Q0 + TEST_DATA_ITEM_123Q6TT2 + TEST_DATA_ITEM_1282Y9T3 + TEST_DATA_ITEM_1282ZJL8 + TEST_DATA_ITEM_129CWDS4 + TEST_DATA_ITEM_12BTZFT5 + TEST_DATA_ITEM_12BV9QP9 + TEST_DATA_ITEM_12C73NW6 + TEST_DATA_ITEM_12C7JPP2 + TEST_DATA_ITEM_12F6LZY6 + TEST_DATA_ITEM_12FCPQP9 + TEST_DATA_ITEM_12MBDC31 + TEST_DATA_ITEM_12MBFPV9 + TEST_DATA_ITEM_12PPWX76 + TEST_DATA_ITEM_12QFVS97 + TEST_DATA_ITEM_12QSDL49 + TEST_DATA_ITEM_12QVB1C9 + TEST_DATA_ITEM_12QX0K80 + TEST_DATA_ITEM_12R3SVM5 + TEST_DATA_ITEM_12THJBR1 + TEST_DATA_ITEM_12TKHH48 + TEST_DATA_ITEM_12V1MCV2 + TEST_DATA_ITEM_12V27BM9 + TEST_DATA_ITEM_12VBH621 + TEST_DATA_ITEM_12W99CF7 + TEST_DATA_ITEM_12WFRGG3 + TEST_DATA_ITEM_12Y71RB8 + TEST_DATA_ITEM_12YL4F48 + TEST_DATA_ITEM_134WCD50 + TEST_DATA_ITEM_135B2107 + TEST_DATA_ITEM_135W7XZ8 + TEST_DATA_ITEM_136KJJM5 + TEST_DATA_ITEM_13978WW3 + TEST_DATA_ITEM_139RY7J0 + TEST_DATA_ITEM_13CYT627 + TEST_DATA_ITEM_13GDWQH5 + TEST_DATA_ITEM_13KKBWZ4 + TEST_DATA_ITEM_13P11C13 + TEST_DATA_ITEM_13P1D8K8 + TEST_DATA_ITEM_13PL2VH9 + TEST_DATA_ITEM_13PRXVT9 + TEST_DATA_ITEM_13THLBR6 + TEST_DATA_ITEM_13ZGNYL5 + TEST_DATA_ITEM_145KKRP1 + TEST_DATA_ITEM_146YWG26 + TEST_DATA_ITEM_149QCWP2 + TEST_DATA_ITEM_14GJ8M40 + TEST_DATA_ITEM_14GJSJM5 + TEST_DATA_ITEM_14J211L8 + TEST_DATA_ITEM_14KFQZV4 + TEST_DATA_ITEM_14QJ4014 + TEST_DATA_ITEM_157C5S06 + TEST_DATA_ITEM_15H3RLY9 + TEST_DATA_ITEM_15LHYNV4 + TEST_DATA_ITEM_160DYBM0 + TEST_DATA_ITEM_16HRS1C1 + TEST_DATA_ITEM_1779WNW5 + TEST_DATA_ITEM_17BXPX26 + TEST_DATA_ITEM_17J18SJ0 + TEST_DATA_ITEM_17J1X165 + TEST_DATA_ITEM_17WSF072 + TEST_DATA_ITEM_17XFZWY7 + TEST_DATA_ITEM_19Y3V5C6 + TEST_DATA_ITEM_1B79XPY8 + + + + DATA.1 + + + DATA.2 + + + + + + + + 3 + + + \ No newline at end of file diff --git a/solr/modules/saved-search/src/test-files/monitor/dangling-test-single-doc-batch.json b/solr/modules/saved-search/src/test-files/monitor/dangling-test-single-doc-batch.json new file mode 100644 index 00000000000..19d5fff4a76 --- /dev/null +++ b/solr/modules/saved-search/src/test-files/monitor/dangling-test-single-doc-batch.json @@ -0,0 +1,10 @@ +{ + "params": { + "reverseSearchDocuments": [ + { + "id": "0", + "content1_s": "lift" + } + ] + } +} \ No newline at end of file diff --git a/solr/modules/saved-search/src/test-files/monitor/doc0.json b/solr/modules/saved-search/src/test-files/monitor/doc0.json new file mode 100644 index 00000000000..40ee08fd3ee --- /dev/null +++ b/solr/modules/saved-search/src/test-files/monitor/doc0.json @@ -0,0 +1,9 @@ +{ + "params": { + "reverseSearchDocuments": [ + { + "content_s": "elevator stairs" + } + ] + } +} \ No newline at end of file diff --git a/solr/modules/saved-search/src/test-files/monitor/doc1.json b/solr/modules/saved-search/src/test-files/monitor/doc1.json new file mode 100644 index 00000000000..af95e4a35a1 --- /dev/null +++ b/solr/modules/saved-search/src/test-files/monitor/doc1.json @@ -0,0 +1,9 @@ +{ + "params": { + "reverseSearchDocuments": [ + { + "content_s": "something else" + } + ] + } +} \ No newline at end of file diff --git a/solr/modules/saved-search/src/test-files/monitor/doc2.json b/solr/modules/saved-search/src/test-files/monitor/doc2.json new file mode 100644 index 00000000000..386b3bb68ad --- /dev/null +++ b/solr/modules/saved-search/src/test-files/monitor/doc2.json @@ -0,0 +1,10 @@ +{ + "params": { + "reverseSearchDocuments": [ + { + "content_s": "more weird content", + "other_content_s": "solr is cool" + } + ] + } +} \ No newline at end of file diff --git a/solr/modules/saved-search/src/test-files/monitor/elevator-doc.json b/solr/modules/saved-search/src/test-files/monitor/elevator-doc.json new file mode 100644 index 00000000000..83dcec61e80 --- /dev/null +++ b/solr/modules/saved-search/src/test-files/monitor/elevator-doc.json @@ -0,0 +1,12 @@ +{ + "params": { + "reverseSearchDocuments": [ + { + "id": "0", + "content0_s": "elevator stairs", + "content1_s": "winda schody", + "content2_s": "aufzug stufen" + } + ] + } +} \ No newline at end of file diff --git a/solr/modules/saved-search/src/test-files/monitor/multi-value-doc.json b/solr/modules/saved-search/src/test-files/monitor/multi-value-doc.json new file mode 100644 index 00000000000..8984517c33a --- /dev/null +++ b/solr/modules/saved-search/src/test-files/monitor/multi-value-doc.json @@ -0,0 +1,11 @@ +{ + "params": { + "reverseSearchDocuments": [ + { + "id": "4", + "content_s": ["elevator stairs", "something else", "test test test"], + "other_content_s": "I'm tired" + } + ] + } +} \ No newline at end of file diff --git a/solr/modules/saved-search/src/test-files/solr/collection1/core.properties b/solr/modules/saved-search/src/test-files/solr/collection1/core.properties new file mode 100644 index 00000000000..b0ef0785a79 --- /dev/null +++ b/solr/modules/saved-search/src/test-files/solr/collection1/core.properties @@ -0,0 +1,20 @@ +# +# /* +# * Licensed to the Apache Software Foundation (ASF) under one or more +# * contributor license agreements. See the NOTICE file distributed with +# * this work for additional information regarding copyright ownership. +# * The ASF licenses this file to You under the Apache License, Version 2.0 +# * (the "License"); you may not use this file except in compliance with +# * the License. You may obtain a copy of the License at +# * +# * http://www.apache.org/licenses/LICENSE-2.0 +# * +# * Unless required by applicable law or agreed to in writing, software +# * distributed under the License is distributed on an "AS IS" BASIS, +# * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# * See the License for the specific language governing permissions and +# * limitations under the License. +# */ +# + +name=simple \ No newline at end of file diff --git a/solr/modules/saved-search/src/test-files/solr/collection1/schema-aliasing.xml b/solr/modules/saved-search/src/test-files/solr/collection1/schema-aliasing.xml new file mode 100644 index 00000000000..10d2e55deaf --- /dev/null +++ b/solr/modules/saved-search/src/test-files/solr/collection1/schema-aliasing.xml @@ -0,0 +1,101 @@ + + + + + + id + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/solr/modules/saved-search/src/test-files/solr/collection1/schema-stored-mq.xml b/solr/modules/saved-search/src/test-files/solr/collection1/schema-stored-mq.xml new file mode 100644 index 00000000000..734afc91a88 --- /dev/null +++ b/solr/modules/saved-search/src/test-files/solr/collection1/schema-stored-mq.xml @@ -0,0 +1,97 @@ + + + + + + id + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/solr/modules/saved-search/src/test-files/solr/collection1/schema.xml b/solr/modules/saved-search/src/test-files/solr/collection1/schema.xml new file mode 100644 index 00000000000..0aae08b7c01 --- /dev/null +++ b/solr/modules/saved-search/src/test-files/solr/collection1/schema.xml @@ -0,0 +1,98 @@ + + + + + + id + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig-no-cache.xml b/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig-no-cache.xml new file mode 100644 index 00000000000..d9f7389e65f --- /dev/null +++ b/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig-no-cache.xml @@ -0,0 +1,139 @@ + + + + + ${tests.luceneMatchVersion:LATEST} + + ${solr.data.dir:} + + + + + + + ${solr.lock.type:native} + + + + + ${solr.ulog.dir:} + ${solr.ulog.numVersionBuckets:65536} + + + ${solr.autoCommit.maxTime:15000} + false + + + ${solr.autoSoftCommit.maxTime:1000} + + + + 1024 + + + + + true + 20 + 200 + + + + + + + + + false + + + + + + + reverseSearch + + + + + explicit + json + true + id + + + + + explicit + json + true + id + + + + + 0 + false + xml + _version_ + + + + + 0 + /pingQuery + + + all + + + + + TermFilteredPresearcher + true + + + + + + + + + + text/plain; charset=UTF-8 + + + diff --git a/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig-single-core.xml b/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig-single-core.xml new file mode 100644 index 00000000000..26a2a9d0933 --- /dev/null +++ b/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig-single-core.xml @@ -0,0 +1,148 @@ + + + + + ${tests.luceneMatchVersion:LATEST} + + ${solr.data.dir:} + + + + + + + ${solr.lock.type:native} + + + + + ${solr.ulog.dir:} + ${solr.ulog.numVersionBuckets:65536} + + + ${solr.autoCommit.maxTime:15000} + false + + + ${solr.autoSoftCommit.maxTime:1000} + + + + 1024 + + + + + + true + 20 + 200 + + + + + + + + + false + + + + + + + + explicit + json + true + id + + + + + explicit + json + true + id + + + + + 0 + false + xml + _version_ + + + + + 0 + /pingQuery + + + all + + + + + mySolrMonitorCache + MultipassTermFilteredPresearcher + true + 4 + + + + + + + + + + + + + + + + text/plain; charset=UTF-8 + + + diff --git a/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig.xml b/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig.xml new file mode 100644 index 00000000000..c5fb6fbd90e --- /dev/null +++ b/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig.xml @@ -0,0 +1,140 @@ + + + + + ${tests.luceneMatchVersion:LATEST} + + ${solr.data.dir:} + + + + + + + ${solr.lock.type:native} + + + + + ${solr.ulog.dir:} + ${solr.ulog.numVersionBuckets:65536} + + + ${solr.autoCommit.maxTime:15000} + false + + + ${solr.autoSoftCommit.maxTime:1000} + + + + 1024 + + + + + + true + 20 + 200 + + + + + + + + + false + + + + + + + + explicit + json + true + id + + + + + explicit + json + true + id + + + + + 0 + false + xml + _version_ + + + + + 0 + /pingQuery + + + all + + + + + TermFilteredPresearcher + + + + + + + + + + text/plain; charset=UTF-8 + + + diff --git a/solr/modules/saved-search/src/test-files/solr/solr.xml b/solr/modules/saved-search/src/test-files/solr/solr.xml new file mode 100644 index 00000000000..af58afdeb32 --- /dev/null +++ b/solr/modules/saved-search/src/test-files/solr/solr.xml @@ -0,0 +1,28 @@ + + + + + + cores/ + + + ${urlScheme:} + + \ No newline at end of file diff --git a/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/NoCacheSavedSearchTest.java b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/NoCacheSavedSearchTest.java new file mode 100644 index 00000000000..bebb3030cc2 --- /dev/null +++ b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/NoCacheSavedSearchTest.java @@ -0,0 +1,31 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch; + +import org.junit.BeforeClass; + +public class NoCacheSavedSearchTest extends SavedSearchTest { + + @BeforeClass + public static void beforeSuperClass() { + configString = "solrconfig-no-cache.xml"; + schemaString = "schema-aliasing.xml"; + } +} diff --git a/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SavedSearchTest.java b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SavedSearchTest.java new file mode 100644 index 00000000000..32aa1509225 --- /dev/null +++ b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SavedSearchTest.java @@ -0,0 +1,330 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch; + +import java.io.IOException; +import java.net.URISyntaxException; +import java.net.URL; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; +import org.apache.lucene.monitor.Visitors.MonitorFields; +import org.apache.solr.BaseDistributedSearchTestCase; +import org.apache.solr.client.solrj.response.QueryResponse; +import org.apache.solr.common.SolrDocumentList; +import org.apache.solr.common.params.CommonParams; +import org.junit.Test; + +@SuppressWarnings("unchecked") +public class SavedSearchTest extends BaseDistributedSearchTestCase { + + @Test + public void testMonitorQuery() throws Exception { + index(id, Integer.toString(0), MonitorFields.MONITOR_QUERY, "content_s:\"elevator music\""); + index( + id, + Integer.toString(1), + MonitorFields.MONITOR_QUERY, + "{!xmlparser}steep stairs"); + index(id, Integer.toString(2), MonitorFields.MONITOR_QUERY, "content_s:\"elevator sounds\""); + index(id, Integer.toString(3), MonitorFields.MONITOR_QUERY, "content_s:\"elevator drop\""); + index(id, Integer.toString(4), MonitorFields.MONITOR_QUERY, "content_s:\"elevator stairs\""); + index(id, Integer.toString(5), MonitorFields.MONITOR_QUERY, "other_content_s:\"solr is cool\""); + index(id, Integer.toString(6), MonitorFields.MONITOR_QUERY, "other_content_s:\"solr is lame\""); + index(id, Integer.toString(7), MonitorFields.MONITOR_QUERY, "content_s:something"); + commit(); + handle.clear(); + handle.put("responseHeader", SKIP); + handle.put("response", SKIP); + + Object[] params = + new Object[] { + CommonParams.SORT, + MonitorFields.QUERY_ID + " desc", + CommonParams.JSON, + read("/monitor/doc1.json"), + CommonParams.QT, + "/reverseSearch" + }; + QueryResponse response = query(params); + System.out.println("Response = " + response); + validateDocList(response, List.of("7")); + } + + @Test + @ShardsFixed(num = 3) + public void testMonitorQueryWithUpdate() throws Exception { + index(id, Integer.toString(0), MonitorFields.MONITOR_QUERY, "content_s:\"elevator music\""); + index( + id, + Integer.toString(1), + MonitorFields.MONITOR_QUERY, + "{!xmlparser}steep stairs"); + index(id, Integer.toString(2), MonitorFields.MONITOR_QUERY, "content_s:\"elevator sounds\""); + index(id, Integer.toString(3), MonitorFields.MONITOR_QUERY, "content_s:\"elevator drop\""); + index(id, Integer.toString(4), MonitorFields.MONITOR_QUERY, "content_s:\"elevator stairs\""); + index(id, Integer.toString(5), MonitorFields.MONITOR_QUERY, "other_content_s:\"solr is cool\""); + index(id, Integer.toString(6), MonitorFields.MONITOR_QUERY, "other_content_s:\"solr is lame\""); + index(id, Integer.toString(7), MonitorFields.MONITOR_QUERY, "content_s:something"); + commit(); + handle.clear(); + handle.put("responseHeader", SKIP); + handle.put("response", SKIP); + + Object[] params = + new Object[] { + CommonParams.SORT, + MonitorFields.QUERY_ID + " desc", + CommonParams.JSON, + read("/monitor/doc0.json"), + CommonParams.QT, + "/reverseSearch" + }; + QueryResponse response = query(params); + System.out.println("Response = " + response); + validateDocList(response, List.of("4", "1")); + assertEquals(2, ((SolrDocumentList) response.getResponse().get("response")).size()); + + index(id, Integer.toString(5), MonitorFields.MONITOR_QUERY, "other_content_s:\"solr is lame\""); + index(id, Integer.toString(6), MonitorFields.MONITOR_QUERY, "other_content_s:\"solr is cool\""); + index( + id, + Integer.toString(1), + MonitorFields.MONITOR_QUERY, + "{!xmlparser}steep hill"); + index(id, Integer.toString(2), MonitorFields.MONITOR_QUERY, "content_s:elevator"); + commit(); + handle.clear(); + handle.put("responseHeader", SKIP); + handle.put("response", SKIP); + + params = + new Object[] { + CommonParams.SORT, + id + " desc", + CommonParams.JSON, + read("/monitor/doc2.json"), + CommonParams.QT, + "/reverseSearch" + }; + response = query(params); + validateDocList(response, List.of("6")); + } + + @Test + public void testDefaultParser() throws Exception { + index(id, Integer.toString(0), MonitorFields.MONITOR_QUERY, "content_s:\"elevator stairs\""); + index(id, Integer.toString(1), MonitorFields.MONITOR_QUERY, "content_s:\"something else\""); + commit(); + handle.clear(); + handle.put("responseHeader", SKIP); + handle.put("response", SKIP); + + Object[] params = + new Object[] { + CommonParams.SORT, + id + " desc", + CommonParams.JSON, + read("/monitor/multi-value-doc.json"), + CommonParams.QT, + "/reverseSearch" + }; + + QueryResponse response = query(params); + System.out.println("Response = " + response); + validateDocList(response, List.of("1", "0")); + } + + @Test + @ShardsFixed(num = 2) + public void testDisjunctionQuery() throws Exception { + index( + id, + Integer.toString(0), + MonitorFields.MONITOR_QUERY, + "{!xmlparser}elevatorwindastufen"); + index( + id, + Integer.toString(1), + MonitorFields.MONITOR_QUERY, + "{!xmlparser}nottheseterms"); + commit(); + handle.clear(); + handle.put("responseHeader", SKIP); + handle.put("response", SKIP); + + Object[] params = + new Object[] { + CommonParams.SORT, + id + " desc", + CommonParams.JSON, + read("/monitor/elevator-doc.json"), + CommonParams.QT, + "/reverseSearch" + }; + + QueryResponse response = query(params); + System.out.println("Response = " + response); + validateDocList(response, List.of("0")); + } + + @Test + public void testNoDanglingDecomposition() throws Exception { + index( + id, + Integer.toString(0), + MonitorFields.MONITOR_QUERY, + "{!xmlparser}elevatorlift"); + commit(); + handle.clear(); + handle.put("responseHeader", SKIP); + handle.put("response", SKIP); + + Object[] params = + new Object[] { + CommonParams.SORT, + id + " desc", + CommonParams.JSON, + read("/monitor/dangling-test-single-doc-batch.json"), + CommonParams.QT, + "/reverseSearch" + }; + + QueryResponse response = query(params); + System.out.println("Response = " + response); + validateDocList(response, List.of("0")); + + index( + id, + Integer.toString(0), + MonitorFields.MONITOR_QUERY, + "{!xmlparser}elevator"); + commit(); + response = query(params); + System.out.println("Response = " + response); + validateDocList(response, List.of()); + } + + @Test + public void testNotQuery() throws Exception { + index( + id, + Integer.toString(0), + MonitorFields.MONITOR_QUERY, + "*:* -content0_s:\"elevator stairs\""); + index(id, Integer.toString(1), MonitorFields.MONITOR_QUERY, "*:* -content_s:\"candy canes\""); + commit(); + handle.clear(); + handle.put("responseHeader", SKIP); + handle.put("response", SKIP); + + Object[] params = + new Object[] { + CommonParams.SORT, + id + " desc", + CommonParams.JSON, + read("/monitor/elevator-doc.json"), + CommonParams.QT, + "/reverseSearch" + }; + + QueryResponse response = query(params); + System.out.println("Response = " + response); + validateDocList(response, List.of("1")); + } + + @Test + public void testWildCardQuery() throws Exception { + index(id, Integer.toString(0), MonitorFields.MONITOR_QUERY, "content_s:te*"); + index(id, Integer.toString(1), MonitorFields.MONITOR_QUERY, "content_s:tes*"); + index(id, Integer.toString(2), MonitorFields.MONITOR_QUERY, "content_s:test*"); + index(id, Integer.toString(3), MonitorFields.MONITOR_QUERY, "content_s:tex*"); + index(id, Integer.toString(4), MonitorFields.MONITOR_QUERY, "content_s:tests*"); + commit(); + handle.clear(); + handle.put("responseHeader", SKIP); + handle.put("response", SKIP); + + Object[] params = + new Object[] { + CommonParams.SORT, + id + " desc", + CommonParams.JSON, + read("/monitor/multi-value-doc.json"), + CommonParams.QT, + "/reverseSearch" + }; + + QueryResponse response = query(params); + System.out.println("Response = " + response); + validateDocList(response, List.of("2", "1", "0")); + } + + @Test + public void testDeleteByQueryId() throws Exception { + index( + id, + Integer.toString(0), + MonitorFields.MONITOR_QUERY, + "{!xmlparser}elevatorlift"); + commit(); + handle.clear(); + handle.put("responseHeader", SKIP); + handle.put("response", SKIP); + + Object[] params = + new Object[] { + CommonParams.SORT, + id + " desc", + CommonParams.JSON, + read("/monitor/dangling-test-single-doc-batch.json"), + CommonParams.QT, + "/reverseSearch" + }; + + QueryResponse response = query(params); + validateDocList(response, List.of("0")); + + del(MonitorFields.QUERY_ID + ":0"); + commit(); + response = query(CommonParams.Q, "*:*"); + validateDocList(response, List.of()); + } + + void validateDocList(QueryResponse response, Object expectedValue) { + SolrDocumentList actualValues = (SolrDocumentList) response.getResponse().get("response"); + // minimal checks only so far; TODO: make this more comprehensive + if (expectedValue instanceof List) { + List expectedValues = (List) expectedValue; + int i = 0; + assertEquals(expectedValues.size(), actualValues.size()); + for (var ev : expectedValues) { + assertEquals(ev, actualValues.get(i).getFieldValue(MonitorFields.QUERY_ID)); + i++; + } + } + } + + protected String read(String resourceName) throws IOException, URISyntaxException { + final URL url = getClass().getResource(resourceName); + return Files.readString(Path.of(url.toURI()), StandardCharsets.UTF_8); + } +} diff --git a/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SingleCoreSavedSearchTest.java b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SingleCoreSavedSearchTest.java new file mode 100644 index 00000000000..0ad7560207b --- /dev/null +++ b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SingleCoreSavedSearchTest.java @@ -0,0 +1,226 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch; + +import java.net.URL; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Locale; +import java.util.stream.IntStream; +import org.apache.lucene.monitor.Visitors.MonitorFields; +import org.apache.solr.SolrTestCaseJ4; +import org.apache.solr.common.SolrException; +import org.apache.solr.common.params.CommonParams; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; + +public class SingleCoreSavedSearchTest extends SolrTestCaseJ4 { + + private final String monitorChain = "monitor"; + + @BeforeClass + public static void beforeTests() throws Exception { + initCore("solrconfig-single-core.xml", "schema-aliasing.xml"); + } + + @Override + @Before + public void setUp() throws Exception { + super.setUp(); + clearIndex(); + assertU(commit()); + } + + @Test + public void coexistWithRegularDocumentsTest() throws Exception { + String regularChain = "regular-ole-document"; + addDoc(adoc("id", "0", "content_s", "some unremarkable content"), regularChain); + addDoc(commit(), regularChain); + addDoc(adoc("id", "1", MonitorFields.MONITOR_QUERY, "content_s:test"), monitorChain); + addDoc(commit(), monitorChain); + URL url = getClass().getResource("/monitor/multi-value-doc.json"); + String json = Files.readString(Path.of(url.toURI()), StandardCharsets.UTF_8); + + String[] params = + new String[] { + CommonParams.SORT, "id desc", CommonParams.JSON, json, CommonParams.QT, "/reverseSearch" + }; + + assertQ(req(params), "//*[@numFound='1']"); + } + + @Test + public void queryStringIdTest() throws Exception { + addDoc(adoc("id", "1", MonitorFields.MONITOR_QUERY, "id:4"), monitorChain); + addDoc(adoc("id", "2", MonitorFields.MONITOR_QUERY, "id:4"), monitorChain); + addDoc(commit(), monitorChain); + URL url = getClass().getResource("/monitor/multi-value-doc.json"); + String json = Files.readString(Path.of(url.toURI()), StandardCharsets.UTF_8); + + String[] params = + new String[] { + CommonParams.SORT, "id desc", CommonParams.JSON, json, CommonParams.QT, "/reverseSearch" + }; + + assertQ(req(params), "//*[@numFound='2']"); + } + + @Test + public void missingQueryFieldTest() { + var ex = assertThrows(SolrException.class, () -> addDoc(adoc("id", "1"), monitorChain)); + assertEquals(SolrException.ErrorCode.BAD_REQUEST.code, ex.code()); + String lowerCaseMessage = ex.getMessage().toLowerCase(Locale.ROOT); + assertTrue(lowerCaseMessage.contains("missing")); + assertTrue(lowerCaseMessage.contains("mandatory")); + assertTrue(ex.getMessage().contains(MonitorFields.MONITOR_QUERY)); + assertTrue(lowerCaseMessage.contains("field")); + } + + @Test + public void unsupportedFieldTest() { + String unsupportedField1 = "unsupported2_s"; + String unsupportedField2 = "unsupported2_s"; + var ex = + assertThrows( + SolrException.class, + () -> + addDoc( + adoc( + "id", + "1", + MonitorFields.MONITOR_QUERY, + "content_s:test", + unsupportedField1, + "a", + unsupportedField2, + "b"), + monitorChain)); + assertEquals(SolrException.ErrorCode.BAD_REQUEST.code, ex.code()); + String lowerCaseMessage = ex.getMessage().toLowerCase(Locale.ROOT); + assertTrue(lowerCaseMessage.contains("unsupported")); + assertTrue(lowerCaseMessage.contains("fields")); + assertTrue(lowerCaseMessage.contains(unsupportedField1)); + assertTrue(lowerCaseMessage.contains(unsupportedField2)); + } + + @Test + public void multiPassPresearcherTest() throws Exception { + addDoc( + adoc( + "id", "0", MonitorFields.MONITOR_QUERY, "content0_s:\"elevator stairs and escalator\""), + monitorChain); + addDoc( + adoc("id", "1", MonitorFields.MONITOR_QUERY, "content0_s:\"elevator test\""), monitorChain); + addDoc( + adoc("id", "2", MonitorFields.MONITOR_QUERY, "content0_s:\"stairs test\""), monitorChain); + addDoc( + adoc("id", "3", MonitorFields.MONITOR_QUERY, "content0_s:\"elevator stairs\""), + monitorChain); + addDoc(commit(), monitorChain); + URL url = getClass().getResource("/monitor/elevator-doc.json"); + String json = Files.readString(Path.of(url.toURI()), StandardCharsets.UTF_8); + + String[] params = + new String[] { + CommonParams.SORT, + "id desc", + CommonParams.JSON, + json, + CommonParams.QT, + "/reverseSearch", + CommonParams.DEBUG_QUERY, + "true" + }; + + assertQ( + req(params), + "//*[@numFound='1']", + "/response/lst[@name=\"debug\"]/lst[@name=\"reverse-search-debug\"]/int[@name=\"queriesRun\"]/text()='1'"); + } + + @Test + public void manySegmentsQuery() throws Exception { + int count = 10_000; + IntStream.range(0, count) + .forEach( + i -> { + try { + addDoc( + adoc( + "id", + Integer.toString(i), + MonitorFields.MONITOR_QUERY, + "content_s:\"elevator stairs\""), + monitorChain); + } catch (Exception e) { + throw new IllegalStateException(e); + } + }); + addDoc(commit(), monitorChain); + URL url = getClass().getResource("/monitor/multi-value-doc.json"); + String json = Files.readString(Path.of(url.toURI()), StandardCharsets.UTF_8); + + String[] params = + new String[] { + CommonParams.SORT, + "id desc", + CommonParams.JSON, + json, + CommonParams.QT, + "/reverseSearch", + CommonParams.DEBUG_QUERY, + "true", + "multiThreaded", + "true" + }; + + assertQ( + req(params), + "//*[@numFound='" + count + "']", + "/response/lst[@name=\"debug\"]/lst[@name=\"reverse-search-debug\"]/int[@name=\"queriesRun\"]/text()='" + + count + + "'"); + + IntStream.range(count / 2, count) + .forEach( + i -> { + try { + addDoc( + adoc( + "id", + Integer.toString(i), + MonitorFields.MONITOR_QUERY, + "content_s:\"x y\""), + monitorChain); + } catch (Exception e) { + throw new IllegalStateException(e); + } + }); + addDoc(commit(), monitorChain); + assertQ( + req(params), + "//*[@numFound='" + count / 2 + "']", + "/response/lst[@name=\"debug\"]/lst[@name=\"reverse-search-debug\"]/int[@name=\"queriesRun\"]/text()='" + + count / 2 + + "'"); + } +} diff --git a/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/StoredSavedSearchTest.java b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/StoredSavedSearchTest.java new file mode 100644 index 00000000000..96167ecb484 --- /dev/null +++ b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/StoredSavedSearchTest.java @@ -0,0 +1,42 @@ +/* + * + * * Licensed to the Apache Software Foundation (ASF) under one or more + * * contributor license agreements. See the NOTICE file distributed with + * * this work for additional information regarding copyright ownership. + * * The ASF licenses this file to You under the Apache License, Version 2.0 + * * (the "License"); you may not use this file except in compliance with + * * the License. You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.apache.solr.savedsearch; + +import org.apache.lucene.monitor.Visitors.MonitorFields; +import org.junit.BeforeClass; +import org.junit.Test; + +public class StoredSavedSearchTest extends SavedSearchTest { + + @BeforeClass + public static void beforeSuperClass() { + schemaString = "schema-stored-mq.xml"; + } + + @Test + public void indexBigQueryTest() throws Exception { + index( + id, + Integer.toString(0), + MonitorFields.MONITOR_QUERY, + "{!xmlparser}" + read("/monitor/BigDisjunctionQuery.xml")); + commit(); + } +} diff --git a/versions.lock b/versions.lock index b2bec0363ed..b6df8a9d6ec 100644 --- a/versions.lock +++ b/versions.lock @@ -12,29 +12,29 @@ "com.amazonaws:aws-java-sdk-s3:1.12.501" : "1e12e466,refs=2", "com.amazonaws:jmespath-java:1.12.501" : "1e12e466,refs=2", "com.beust:jcommander:1.82" : "50a667d1,refs=5", - "com.carrotsearch.randomizedtesting:randomizedtesting-runner:2.8.1" : "06ca9183,refs=52", - "com.carrotsearch:hppc:0.10.0" : "3ff3bc39,refs=81", + "com.carrotsearch.randomizedtesting:randomizedtesting-runner:2.8.1" : "e9094088,refs=54", + "com.carrotsearch:hppc:0.10.0" : "d10c49c4,refs=85", "com.cybozu.labs:langdetect:1.1-20120112" : "69bf1b73,refs=5", "com.epam:parso:2.0.14" : "50a667d1,refs=5", - "com.fasterxml.jackson.core:jackson-annotations:2.18.0" : "4ce82561,refs=99", - "com.fasterxml.jackson.core:jackson-core:2.18.0" : "6a8501ec,refs=100", - "com.fasterxml.jackson.core:jackson-databind:2.18.0" : "f83d8628,refs=96", - "com.fasterxml.jackson.dataformat:jackson-dataformat-cbor:2.18.0" : "8b517977,refs=81", + "com.fasterxml.jackson.core:jackson-annotations:2.18.0" : "987aa92c,refs=103", + "com.fasterxml.jackson.core:jackson-core:2.18.0" : "abf04837,refs=104", + "com.fasterxml.jackson.core:jackson-databind:2.18.0" : "e5144e73,refs=100", + "com.fasterxml.jackson.dataformat:jackson-dataformat-cbor:2.18.0" : "90ad3802,refs=85", "com.fasterxml.jackson.dataformat:jackson-dataformat-csv:2.18.0" : "4bf37e93,refs=3", - "com.fasterxml.jackson.dataformat:jackson-dataformat-smile:2.18.0" : "ad8f08d7,refs=79", + "com.fasterxml.jackson.dataformat:jackson-dataformat-smile:2.18.0" : "30d41762,refs=83", "com.fasterxml.jackson.dataformat:jackson-dataformat-xml:2.18.0" : "1e12e466,refs=2", "com.fasterxml.jackson.datatype:jackson-datatype-jdk8:2.18.0" : "3b210678,refs=5", "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.18.0" : "1e12e466,refs=2", - "com.fasterxml.jackson.module:jackson-module-jakarta-xmlbind-annotations:2.18.0" : "ad8f08d7,refs=79", + "com.fasterxml.jackson.module:jackson-module-jakarta-xmlbind-annotations:2.18.0" : "30d41762,refs=83", "com.fasterxml.jackson.module:jackson-module-kotlin:2.18.0" : "c77c5ec7,refs=1", "com.fasterxml.jackson.module:jackson-module-parameter-names:2.18.0" : "1e12e466,refs=2", "com.fasterxml.jackson.module:jackson-module-scala_2.13:2.18.0" : "4bf37e93,refs=3", - "com.fasterxml.jackson:jackson-bom:2.18.0" : "100652ac,refs=104", - "com.fasterxml.woodstox:woodstox-core:7.0.0" : "7bb67147,refs=82", - "com.github.ben-manes.caffeine:caffeine:3.1.8" : "5b2db4f4,refs=111", + "com.fasterxml.jackson:jackson-bom:2.18.0" : "1adb38f7,refs=108", + "com.fasterxml.woodstox:woodstox-core:7.0.0" : "5331c7d2,refs=86", + "com.github.ben-manes.caffeine:caffeine:3.1.8" : "1bda69a3,refs=118", "com.github.jai-imageio:jai-imageio-core:1.4.0" : "50a667d1,refs=5", "com.github.junrar:junrar:7.5.3" : "50a667d1,refs=5", - "com.github.kevinstern:software-and-algorithms:1.0" : "e5b524d7,refs=26", + "com.github.kevinstern:software-and-algorithms:1.0" : "a9f15c33,refs=27", "com.github.luben:zstd-jni:1.5.6-3" : "f493e7bb,refs=7", "com.github.openjson:openjson:1.0.12" : "50a667d1,refs=5", "com.github.spotbugs:spotbugs-annotations:4.8.6" : "761c3c3c,refs=5", @@ -54,33 +54,33 @@ "com.google.apis:google-api-services-storage:v1-rev20240621-2.0.0" : "784a94ea,refs=5", "com.google.auth:google-auth-library-credentials:1.23.0" : "784a94ea,refs=5", "com.google.auth:google-auth-library-oauth2-http:1.23.0" : "784a94ea,refs=5", - "com.google.auto.service:auto-service-annotations:1.0.1" : "e5b524d7,refs=26", - "com.google.auto.value:auto-value-annotations:1.10.4" : "322f4a3c,refs=31", - "com.google.auto:auto-common:1.2.2" : "e5b524d7,refs=26", + "com.google.auto.service:auto-service-annotations:1.0.1" : "a9f15c33,refs=27", + "com.google.auto.value:auto-value-annotations:1.10.4" : "ecbbe36e,refs=32", + "com.google.auto:auto-common:1.2.2" : "a9f15c33,refs=27", "com.google.cloud:google-cloud-bom:0.224.0" : "784a94ea,refs=5", "com.google.cloud:google-cloud-core:2.40.0" : "784a94ea,refs=5", "com.google.cloud:google-cloud-core-grpc:2.40.0" : "784a94ea,refs=5", "com.google.cloud:google-cloud-core-http:2.40.0" : "784a94ea,refs=5", "com.google.cloud:google-cloud-nio:0.127.20" : "aa7a59c6,refs=2", "com.google.cloud:google-cloud-storage:2.40.1" : "784a94ea,refs=5", - "com.google.code.findbugs:jsr305:3.0.2" : "e5b524d7,refs=26", + "com.google.code.findbugs:jsr305:3.0.2" : "a9f15c33,refs=27", "com.google.code.gson:gson:2.11.0" : "0a82b27c,refs=16", - "com.google.errorprone:error_prone_annotation:2.31.0" : "e5b524d7,refs=26", - "com.google.errorprone:error_prone_annotations:2.31.0" : "e80f7a3a,refs=149", - "com.google.errorprone:error_prone_check_api:2.31.0" : "e5b524d7,refs=26", - "com.google.errorprone:error_prone_core:2.31.0" : "e5b524d7,refs=26", - "com.google.errorprone:error_prone_type_annotations:2.31.0" : "e5b524d7,refs=26", - "com.google.guava:failureaccess:1.0.2" : "e80f7a3a,refs=149", - "com.google.guava:guava:33.1.0-jre" : "e80f7a3a,refs=149", - "com.google.guava:listenablefuture:9999.0-empty-to-avoid-conflict-with-guava" : "e80f7a3a,refs=149", + "com.google.errorprone:error_prone_annotation:2.31.0" : "a9f15c33,refs=27", + "com.google.errorprone:error_prone_annotations:2.31.0" : "b48c15dd,refs=156", + "com.google.errorprone:error_prone_check_api:2.31.0" : "a9f15c33,refs=27", + "com.google.errorprone:error_prone_core:2.31.0" : "a9f15c33,refs=27", + "com.google.errorprone:error_prone_type_annotations:2.31.0" : "a9f15c33,refs=27", + "com.google.guava:failureaccess:1.0.2" : "b48c15dd,refs=156", + "com.google.guava:guava:33.1.0-jre" : "b48c15dd,refs=156", + "com.google.guava:listenablefuture:9999.0-empty-to-avoid-conflict-with-guava" : "b48c15dd,refs=156", "com.google.http-client:google-http-client:1.44.2" : "784a94ea,refs=5", "com.google.http-client:google-http-client-apache-v2:1.44.2" : "784a94ea,refs=5", "com.google.http-client:google-http-client-appengine:1.44.2" : "784a94ea,refs=5", "com.google.http-client:google-http-client-gson:1.44.2" : "784a94ea,refs=5", "com.google.http-client:google-http-client-jackson2:1.44.2" : "784a94ea,refs=5", - "com.google.j2objc:j2objc-annotations:3.0.0" : "a05ffa28,refs=49", + "com.google.j2objc:j2objc-annotations:3.0.0" : "ece6e856,refs=51", "com.google.oauth-client:google-oauth-client:1.36.0" : "784a94ea,refs=5", - "com.google.protobuf:protobuf-java:3.25.3" : "7498dc3d,refs=48", + "com.google.protobuf:protobuf-java:3.25.3" : "98f116c7,refs=49", "com.google.protobuf:protobuf-java-util:3.25.3" : "a7f96198,refs=8", "com.google.re2j:re2j:1.7" : "a5b348ef,refs=6", "com.googlecode.json-simple:json-simple:1.1.1" : "8d0cef4c,refs=11", @@ -90,9 +90,9 @@ "com.healthmarketscience.jackcess:jackcess-encrypt:4.0.1" : "50a667d1,refs=5", "com.helger:profiler:1.1.1" : "0769b123,refs=5", "com.ibm.icu:icu4j:74.2" : "b4755bf3,refs=9", - "com.j256.simplemagic:simplemagic:1.17" : "ad8f08d7,refs=79", - "com.jayway.jsonpath:json-path:2.9.0" : "ad8f08d7,refs=79", - "com.lmax:disruptor:3.4.4" : "6ac4140f,refs=27", + "com.j256.simplemagic:simplemagic:1.17" : "30d41762,refs=83", + "com.jayway.jsonpath:json-path:2.9.0" : "30d41762,refs=83", + "com.lmax:disruptor:3.4.4" : "baa40a7b,refs=28", "com.mchange:c3p0:0.9.5.5" : "50a667d1,refs=5", "com.mchange:mchange-commons-java:0.2.19" : "50a667d1,refs=5", "com.nimbusds:content-type:2.2" : "4f81d786,refs=2", @@ -108,17 +108,17 @@ "com.squareup.okio:okio-jvm:3.6.0" : "b6a343e2,refs=5", "com.sun.activation:jakarta.activation:1.2.2" : "e2f3f42e,refs=4", "com.sun.istack:istack-commons-runtime:3.0.12" : "debe9836,refs=7", - "com.tdunning:t-digest:3.3" : "ad8f08d7,refs=79", + "com.tdunning:t-digest:3.3" : "30d41762,refs=83", "com.thoughtworks.paranamer:paranamer:2.8" : "4bf37e93,refs=3", "com.typesafe.scala-logging:scala-logging_2.13:3.9.4" : "4bf37e93,refs=3", "com.yammer.metrics:metrics-core:2.2.0" : "4bf37e93,refs=3", "com.zaxxer:SparseBitSet:1.2" : "50a667d1,refs=5", "commons-beanutils:commons-beanutils:1.9.4" : "4bf37e93,refs=3", - "commons-cli:commons-cli:1.9.0" : "e19ba4dc,refs=87", - "commons-codec:commons-codec:1.17.1" : "fed35e7f,refs=107", + "commons-cli:commons-cli:1.9.0" : "157928e7,refs=91", + "commons-codec:commons-codec:1.17.1" : "f725590a,refs=111", "commons-collections:commons-collections:3.2.2" : "acc31ef6,refs=6", "commons-digester:commons-digester:2.1" : "4bf37e93,refs=3", - "commons-io:commons-io:2.15.1" : "7413b098,refs=124", + "commons-io:commons-io:2.15.1" : "27d9a2c5,refs=130", "commons-validator:commons-validator:1.7" : "4bf37e93,refs=3", "de.l3s.boilerpipe:boilerpipe:1.1.0" : "50a667d1,refs=5", "edu.ucar:cdm:4.5.5" : "50a667d1,refs=5", @@ -127,17 +127,17 @@ "edu.ucar:netcdf4:4.5.5" : "50a667d1,refs=5", "edu.ucar:udunits:4.5.5" : "50a667d1,refs=5", "edu.usc.ir:sentiment-analysis-parser:0.1" : "50a667d1,refs=5", - "io.dropwizard.metrics:metrics-annotation:4.2.26" : "1f5bde05,refs=47", - "io.dropwizard.metrics:metrics-core:4.2.26" : "87cd582a,refs=121", - "io.dropwizard.metrics:metrics-graphite:4.2.26" : "27f62655,refs=81", + "io.dropwizard.metrics:metrics-annotation:4.2.26" : "762fd911,refs=49", + "io.dropwizard.metrics:metrics-core:4.2.26" : "28c7d4d7,refs=127", + "io.dropwizard.metrics:metrics-graphite:4.2.26" : "bf5445e0,refs=85", "io.dropwizard.metrics:metrics-healthchecks:4.2.26" : "0769b123,refs=5", - "io.dropwizard.metrics:metrics-jetty10:4.2.26" : "1f5bde05,refs=47", - "io.dropwizard.metrics:metrics-jmx:4.2.26" : "27f62655,refs=81", + "io.dropwizard.metrics:metrics-jetty10:4.2.26" : "762fd911,refs=49", + "io.dropwizard.metrics:metrics-jmx:4.2.26" : "bf5445e0,refs=85", "io.dropwizard.metrics:metrics-json:4.2.26" : "0769b123,refs=5", - "io.dropwizard.metrics:metrics-jvm:4.2.26" : "dc28f153,refs=83", + "io.dropwizard.metrics:metrics-jvm:4.2.26" : "370d61de,refs=87", "io.dropwizard.metrics:metrics-servlets:4.2.26" : "0769b123,refs=5", - "io.github.eisop:dataflow-errorprone:3.41.0-eisop1" : "e5b524d7,refs=26", - "io.github.java-diff-utils:java-diff-utils:4.12" : "e5b524d7,refs=26", + "io.github.eisop:dataflow-errorprone:3.41.0-eisop1" : "a9f15c33,refs=27", + "io.github.java-diff-utils:java-diff-utils:4.12" : "a9f15c33,refs=27", "io.github.microutils:kotlin-logging:3.0.5" : "c77c5ec7,refs=1", "io.github.microutils:kotlin-logging-jvm:3.0.5" : "c77c5ec7,refs=1", "io.grpc:grpc-alts:1.65.1" : "784a94ea,refs=5", @@ -160,28 +160,28 @@ "io.grpc:grpc-xds:1.65.1" : "6fb73f3a,refs=3", "io.micrometer:micrometer-core:1.9.12" : "1e12e466,refs=2", "io.netty:netty-bom:4.1.114.Final" : "0d28f997,refs=5", - "io.netty:netty-buffer:4.1.114.Final" : "7413b098,refs=124", - "io.netty:netty-codec:4.1.114.Final" : "7413b098,refs=124", + "io.netty:netty-buffer:4.1.114.Final" : "27d9a2c5,refs=130", + "io.netty:netty-codec:4.1.114.Final" : "27d9a2c5,refs=130", "io.netty:netty-codec-http:4.1.114.Final" : "c1e4e901,refs=4", "io.netty:netty-codec-http2:4.1.114.Final" : "5fcc0587,refs=3", "io.netty:netty-codec-socks:4.1.114.Final" : "5fcc0587,refs=3", - "io.netty:netty-common:4.1.114.Final" : "7413b098,refs=124", - "io.netty:netty-handler:4.1.114.Final" : "7413b098,refs=124", + "io.netty:netty-common:4.1.114.Final" : "27d9a2c5,refs=130", + "io.netty:netty-handler:4.1.114.Final" : "27d9a2c5,refs=130", "io.netty:netty-handler-proxy:4.1.114.Final" : "5fcc0587,refs=3", - "io.netty:netty-resolver:4.1.114.Final" : "7413b098,refs=124", - "io.netty:netty-tcnative-boringssl-static:2.0.66.Final" : "7413b098,refs=124", - "io.netty:netty-tcnative-classes:2.0.66.Final" : "7413b098,refs=124", - "io.netty:netty-transport:4.1.114.Final" : "7413b098,refs=124", - "io.netty:netty-transport-classes-epoll:4.1.114.Final" : "7413b098,refs=124", - "io.netty:netty-transport-native-epoll:4.1.114.Final" : "7413b098,refs=124", - "io.netty:netty-transport-native-unix-common:4.1.114.Final" : "7413b098,refs=124", + "io.netty:netty-resolver:4.1.114.Final" : "27d9a2c5,refs=130", + "io.netty:netty-tcnative-boringssl-static:2.0.66.Final" : "27d9a2c5,refs=130", + "io.netty:netty-tcnative-classes:2.0.66.Final" : "27d9a2c5,refs=130", + "io.netty:netty-transport:4.1.114.Final" : "27d9a2c5,refs=130", + "io.netty:netty-transport-classes-epoll:4.1.114.Final" : "27d9a2c5,refs=130", + "io.netty:netty-transport-native-epoll:4.1.114.Final" : "27d9a2c5,refs=130", + "io.netty:netty-transport-native-unix-common:4.1.114.Final" : "27d9a2c5,refs=130", "io.opencensus:opencensus-api:0.31.1" : "784a94ea,refs=5", "io.opencensus:opencensus-contrib-http-util:0.31.1" : "784a94ea,refs=5", "io.opencensus:opencensus-proto:0.2.0" : "6fb73f3a,refs=3", - "io.opentelemetry:opentelemetry-api:1.40.0" : "17e13daa,refs=119", + "io.opentelemetry:opentelemetry-api:1.40.0" : "84b99a57,refs=125", "io.opentelemetry:opentelemetry-api-incubator:1.40.0-alpha" : "5fcc0587,refs=3", "io.opentelemetry:opentelemetry-bom:1.40.0" : "0d28f997,refs=5", - "io.opentelemetry:opentelemetry-context:1.40.0" : "17e13daa,refs=119", + "io.opentelemetry:opentelemetry-context:1.40.0" : "84b99a57,refs=125", "io.opentelemetry:opentelemetry-exporter-common:1.40.0" : "5fcc0587,refs=3", "io.opentelemetry:opentelemetry-exporter-otlp:1.40.0" : "5fcc0587,refs=3", "io.opentelemetry:opentelemetry-exporter-otlp-common:1.40.0" : "5fcc0587,refs=3", @@ -195,25 +195,25 @@ "io.opentelemetry:opentelemetry-sdk-testing:1.40.0" : "015c5766,refs=2", "io.opentelemetry:opentelemetry-sdk-trace:1.40.0" : "0d28f997,refs=5", "io.perfmark:perfmark-api:0.27.0" : "dd724fae,refs=6", - "io.prometheus:prometheus-metrics-exposition-formats:1.1.0" : "ad8f08d7,refs=79", - "io.prometheus:prometheus-metrics-model:1.1.0" : "ad8f08d7,refs=79", + "io.prometheus:prometheus-metrics-exposition-formats:1.1.0" : "30d41762,refs=83", + "io.prometheus:prometheus-metrics-model:1.1.0" : "30d41762,refs=83", "io.prometheus:simpleclient:0.16.0" : "fa7556ff,refs=5", "io.prometheus:simpleclient_common:0.16.0" : "fa7556ff,refs=5", "io.prometheus:simpleclient_httpserver:0.16.0" : "fa7556ff,refs=5", - "io.sgr:s2-geometry-library-java:1.0.0" : "ad8f08d7,refs=79", - "io.swagger.core.v3:swagger-annotations-jakarta:2.2.22" : "420fd813,refs=130", + "io.sgr:s2-geometry-library-java:1.0.0" : "30d41762,refs=83", + "io.swagger.core.v3:swagger-annotations-jakarta:2.2.22" : "067b0200,refs=136", "jakarta.activation:jakarta.activation-api:1.2.2" : "50a667d1,refs=5", - "jakarta.annotation:jakarta.annotation-api:2.1.1" : "78dd58c9,refs=80", - "jakarta.inject:jakarta.inject-api:2.0.1" : "ad8f08d7,refs=79", + "jakarta.annotation:jakarta.annotation-api:2.1.1" : "0bb51e54,refs=84", + "jakarta.inject:jakarta.inject-api:2.0.1" : "30d41762,refs=83", "jakarta.servlet:jakarta.servlet-api:4.0.4" : "1e12e466,refs=2", - "jakarta.validation:jakarta.validation-api:3.0.2" : "ad8f08d7,refs=79", + "jakarta.validation:jakarta.validation-api:3.0.2" : "30d41762,refs=83", "jakarta.websocket:jakarta.websocket-api:1.1.2" : "1e12e466,refs=2", - "jakarta.ws.rs:jakarta.ws.rs-api:3.1.0" : "76db8e26,refs=87", + "jakarta.ws.rs:jakarta.ws.rs-api:3.1.0" : "caaf5d31,refs=91", "jakarta.xml.bind:jakarta.xml.bind-api:2.3.3" : "debe9836,refs=7", - "javax.inject:javax.inject:1" : "a9dcee72,refs=28", + "javax.inject:javax.inject:1" : "6ac2c5f8,refs=29", "javax.measure:unit-api:1.0" : "50a667d1,refs=5", "joda-time:joda-time:2.8.1" : "debe9836,refs=7", - "junit:junit:4.13.2" : "06ca9183,refs=52", + "junit:junit:4.13.2" : "e9094088,refs=54", "net.arnx:jsonic:1.2.7" : "69bf1b73,refs=5", "net.bytebuddy:byte-buddy:1.14.15" : "5f62bd8e,refs=18", "net.bytebuddy:byte-buddy-agent:1.14.15" : "23e8a2eb,refs=4", @@ -225,7 +225,7 @@ "net.sourceforge.argparse4j:argparse4j:0.7.0" : "4bf37e93,refs=3", "net.thisptr:jackson-jq:0.0.13" : "fa7556ff,refs=5", "no.nav.security:mock-oauth2-server:0.5.10" : "4f81d786,refs=2", - "org.antlr:antlr4-runtime:4.11.1" : "ebd3db47,refs=77", + "org.antlr:antlr4-runtime:4.11.1" : "428a31d2,refs=81", "org.apache.calcite.avatica:avatica-core:1.25.0" : "93acde90,refs=6", "org.apache.calcite.avatica:avatica-metrics:1.25.0" : "93acde90,refs=6", "org.apache.calcite:calcite-core:1.37.0" : "93acde90,refs=6", @@ -234,14 +234,14 @@ "org.apache.commons:commons-compress:1.26.1" : "515616b6,refs=7", "org.apache.commons:commons-configuration2:2.11.0" : "280cfec8,refs=3", "org.apache.commons:commons-csv:1.9.0" : "50a667d1,refs=5", - "org.apache.commons:commons-exec:1.4.0" : "5b11e899,refs=81", - "org.apache.commons:commons-lang3:3.15.0" : "36393977,refs=83", - "org.apache.commons:commons-math3:3.6.1" : "21136b15,refs=87", + "org.apache.commons:commons-exec:1.4.0" : "9e7d4624,refs=85", + "org.apache.commons:commons-lang3:3.15.0" : "01b4f802,refs=87", + "org.apache.commons:commons-math3:3.6.1" : "aac12aa0,refs=91", "org.apache.commons:commons-text:1.12.0" : "a6a1e3c5,refs=7", - "org.apache.curator:curator-client:5.7.1" : "703dff64,refs=123", - "org.apache.curator:curator-framework:5.7.1" : "703dff64,refs=123", + "org.apache.curator:curator-client:5.7.1" : "2a08a891,refs=129", + "org.apache.curator:curator-framework:5.7.1" : "2a08a891,refs=129", "org.apache.curator:curator-recipes:5.7.1" : "280cfec8,refs=3", - "org.apache.curator:curator-test:5.7.1" : "3c9a199e,refs=29", + "org.apache.curator:curator-test:5.7.1" : "fcbab398,refs=30", "org.apache.hadoop.thirdparty:hadoop-shaded-guava:1.2.0" : "e972cbed,refs=5", "org.apache.hadoop:hadoop-annotations:3.4.0" : "bf04d2b8,refs=5", "org.apache.hadoop:hadoop-auth:3.4.0" : "bf04d2b8,refs=5", @@ -254,9 +254,9 @@ "org.apache.httpcomponents.client5:httpclient5:5.2.1" : "20f1e0e0,refs=4", "org.apache.httpcomponents.core5:httpcore5:5.2.3" : "20f1e0e0,refs=4", "org.apache.httpcomponents.core5:httpcore5-h2:5.2" : "20f1e0e0,refs=4", - "org.apache.httpcomponents:httpclient:4.5.14" : "1b72eeae,refs=128", - "org.apache.httpcomponents:httpcore:4.4.16" : "1b72eeae,refs=128", - "org.apache.httpcomponents:httpmime:4.5.14" : "1b72eeae,refs=128", + "org.apache.httpcomponents:httpclient:4.5.14" : "da1b785b,refs=134", + "org.apache.httpcomponents:httpcore:4.4.16" : "da1b785b,refs=134", + "org.apache.httpcomponents:httpmime:4.5.14" : "da1b785b,refs=134", "org.apache.james:apache-mime4j-core:0.8.4" : "50a667d1,refs=5", "org.apache.james:apache-mime4j-dom:0.8.4" : "50a667d1,refs=5", "org.apache.kafka:kafka-clients:3.7.1" : "c6acb8a9,refs=11", @@ -283,38 +283,39 @@ "org.apache.kerby:kerby-config:2.0.3" : "1643ad05,refs=4", "org.apache.kerby:kerby-pkix:2.0.3" : "1643ad05,refs=4", "org.apache.kerby:kerby-util:2.0.3" : "1643ad05,refs=4", - "org.apache.logging.log4j:log4j-1.2-api:2.21.0" : "1640bbba,refs=20", - "org.apache.logging.log4j:log4j-api:2.21.0" : "bc8e8214,refs=87", - "org.apache.logging.log4j:log4j-core:2.21.0" : "72c9c512,refs=85", - "org.apache.logging.log4j:log4j-layout-template-json:2.21.0" : "6351de37,refs=19", - "org.apache.logging.log4j:log4j-slf4j2-impl:2.21.0" : "08ef8dc6,refs=81", - "org.apache.logging.log4j:log4j-web:2.21.0" : "6351de37,refs=19", - "org.apache.lucene:lucene-analysis-common:9.11.1" : "17e13daa,refs=119", + "org.apache.logging.log4j:log4j-1.2-api:2.21.0" : "7ebc5830,refs=21", + "org.apache.logging.log4j:log4j-api:2.21.0" : "54caaa1f,refs=91", + "org.apache.logging.log4j:log4j-core:2.21.0" : "25903e1d,refs=89", + "org.apache.logging.log4j:log4j-layout-template-json:2.21.0" : "d3cf8553,refs=20", + "org.apache.logging.log4j:log4j-slf4j2-impl:2.21.0" : "2d7a8cd1,refs=85", + "org.apache.logging.log4j:log4j-web:2.21.0" : "d3cf8553,refs=20", + "org.apache.lucene:lucene-analysis-common:9.11.1" : "84b99a57,refs=125", "org.apache.lucene:lucene-analysis-icu:9.11.1" : "b4755bf3,refs=9", - "org.apache.lucene:lucene-analysis-kuromoji:9.11.1" : "ebd3db47,refs=77", + "org.apache.lucene:lucene-analysis-kuromoji:9.11.1" : "428a31d2,refs=81", "org.apache.lucene:lucene-analysis-morfologik:9.11.1" : "727aea63,refs=7", - "org.apache.lucene:lucene-analysis-nori:9.11.1" : "ebd3db47,refs=77", + "org.apache.lucene:lucene-analysis-nori:9.11.1" : "428a31d2,refs=81", "org.apache.lucene:lucene-analysis-opennlp:9.11.1" : "b4755bf3,refs=9", - "org.apache.lucene:lucene-analysis-phonetic:9.11.1" : "ebd3db47,refs=77", + "org.apache.lucene:lucene-analysis-phonetic:9.11.1" : "428a31d2,refs=81", "org.apache.lucene:lucene-analysis-smartcn:9.11.1" : "727aea63,refs=7", "org.apache.lucene:lucene-analysis-stempel:9.11.1" : "727aea63,refs=7", - "org.apache.lucene:lucene-backward-codecs:9.11.1" : "ad8f08d7,refs=79", - "org.apache.lucene:lucene-classification:9.11.1" : "ad8f08d7,refs=79", - "org.apache.lucene:lucene-codecs:9.11.1" : "ad8f08d7,refs=79", - "org.apache.lucene:lucene-core:9.11.1" : "17e13daa,refs=119", - "org.apache.lucene:lucene-expressions:9.11.1" : "ad8f08d7,refs=79", - "org.apache.lucene:lucene-grouping:9.11.1" : "ad8f08d7,refs=79", - "org.apache.lucene:lucene-highlighter:9.11.1" : "ad8f08d7,refs=79", - "org.apache.lucene:lucene-join:9.11.1" : "ad8f08d7,refs=79", - "org.apache.lucene:lucene-memory:9.11.1" : "ebd3db47,refs=77", - "org.apache.lucene:lucene-misc:9.11.1" : "ad8f08d7,refs=79", - "org.apache.lucene:lucene-queries:9.11.1" : "17e13daa,refs=119", - "org.apache.lucene:lucene-queryparser:9.11.1" : "ad8f08d7,refs=79", - "org.apache.lucene:lucene-sandbox:9.11.1" : "ad8f08d7,refs=79", - "org.apache.lucene:lucene-spatial-extras:9.11.1" : "ad8f08d7,refs=79", - "org.apache.lucene:lucene-spatial3d:9.11.1" : "ad8f08d7,refs=79", - "org.apache.lucene:lucene-suggest:9.11.1" : "b3b7541b,refs=81", - "org.apache.lucene:lucene-test-framework:9.11.1" : "06ca9183,refs=52", + "org.apache.lucene:lucene-backward-codecs:9.11.1" : "30d41762,refs=83", + "org.apache.lucene:lucene-classification:9.11.1" : "30d41762,refs=83", + "org.apache.lucene:lucene-codecs:9.11.1" : "30d41762,refs=83", + "org.apache.lucene:lucene-core:9.11.1" : "84b99a57,refs=125", + "org.apache.lucene:lucene-expressions:9.11.1" : "30d41762,refs=83", + "org.apache.lucene:lucene-grouping:9.11.1" : "30d41762,refs=83", + "org.apache.lucene:lucene-highlighter:9.11.1" : "30d41762,refs=83", + "org.apache.lucene:lucene-join:9.11.1" : "30d41762,refs=83", + "org.apache.lucene:lucene-memory:9.11.1" : "428a31d2,refs=81", + "org.apache.lucene:lucene-misc:9.11.1" : "30d41762,refs=83", + "org.apache.lucene:lucene-monitor:9.11.1" : "afdb2998,refs=5", + "org.apache.lucene:lucene-queries:9.11.1" : "84b99a57,refs=125", + "org.apache.lucene:lucene-queryparser:9.11.1" : "30d41762,refs=83", + "org.apache.lucene:lucene-sandbox:9.11.1" : "30d41762,refs=83", + "org.apache.lucene:lucene-spatial-extras:9.11.1" : "30d41762,refs=83", + "org.apache.lucene:lucene-spatial3d:9.11.1" : "30d41762,refs=83", + "org.apache.lucene:lucene-suggest:9.11.1" : "079d20a6,refs=85", + "org.apache.lucene:lucene-test-framework:9.11.1" : "e9094088,refs=54", "org.apache.opennlp:opennlp-tools:1.9.4" : "e6d93f27,refs=19", "org.apache.pdfbox:fontbox:2.0.26" : "50a667d1,refs=5", "org.apache.pdfbox:jbig2-imageio:3.0.4" : "50a667d1,refs=5", @@ -338,9 +339,9 @@ "org.apache.tomcat.embed:tomcat-embed-el:9.0.76" : "1e12e466,refs=2", "org.apache.tomcat:annotations-api:6.0.53" : "781655d3,refs=1", "org.apache.xmlbeans:xmlbeans:5.0.3" : "50a667d1,refs=5", - "org.apache.zookeeper:zookeeper:3.9.2" : "7413b098,refs=124", - "org.apache.zookeeper:zookeeper-jute:3.9.2" : "7413b098,refs=124", - "org.apiguardian:apiguardian-api:1.1.2" : "5d98342f,refs=33", + "org.apache.zookeeper:zookeeper:3.9.2" : "27d9a2c5,refs=130", + "org.apache.zookeeper:zookeeper-jute:3.9.2" : "27d9a2c5,refs=130", + "org.apiguardian:apiguardian-api:1.1.2" : "87874129,refs=34", "org.bitbucket.b_c:jose4j:0.9.6" : "9bcc8206,refs=8", "org.bouncycastle:bcmail-jdk15on:1.70" : "50a667d1,refs=5", "org.bouncycastle:bcpkix-jdk15on:1.70" : "8ba2f0f7,refs=6", @@ -355,58 +356,58 @@ "org.carrot2:morfologik-polish:2.1.9" : "727aea63,refs=7", "org.carrot2:morfologik-stemming:2.1.9" : "727aea63,refs=7", "org.ccil.cowan.tagsoup:tagsoup:1.2.1" : "50a667d1,refs=5", - "org.checkerframework:checker-qual:3.44.0" : "e80f7a3a,refs=149", + "org.checkerframework:checker-qual:3.44.0" : "b48c15dd,refs=156", "org.codehaus.janino:commons-compiler:3.1.11" : "20f1e0e0,refs=4", "org.codehaus.janino:janino:3.1.11" : "20f1e0e0,refs=4", - "org.codehaus.woodstox:stax2-api:4.2.2" : "5b11e899,refs=81", + "org.codehaus.woodstox:stax2-api:4.2.2" : "9e7d4624,refs=85", "org.codelibs:jhighlight:1.1.0" : "50a667d1,refs=5", "org.conscrypt:conscrypt-openjdk-uber:2.5.2" : "784a94ea,refs=5", - "org.eclipse.jetty.http2:http2-client:10.0.22" : "1b72eeae,refs=128", - "org.eclipse.jetty.http2:http2-common:10.0.22" : "84afbb60,refs=130", - "org.eclipse.jetty.http2:http2-hpack:10.0.22" : "84afbb60,refs=130", - "org.eclipse.jetty.http2:http2-http-client-transport:10.0.22" : "f9ff6c21,refs=84", - "org.eclipse.jetty.http2:http2-server:10.0.22" : "5967e690,refs=32", - "org.eclipse.jetty.toolchain:jetty-servlet-api:4.0.6" : "5e82f1c0,refs=109", - "org.eclipse.jetty:jetty-alpn-client:10.0.22" : "1b72eeae,refs=128", - "org.eclipse.jetty:jetty-alpn-java-client:10.0.22" : "f9ff6c21,refs=84", - "org.eclipse.jetty:jetty-alpn-java-server:10.0.22" : "1069c1cc,refs=30", - "org.eclipse.jetty:jetty-alpn-server:10.0.22" : "5967e690,refs=32", - "org.eclipse.jetty:jetty-client:10.0.22" : "7f2dd9d5,refs=90", + "org.eclipse.jetty.http2:http2-client:10.0.22" : "da1b785b,refs=134", + "org.eclipse.jetty.http2:http2-common:10.0.22" : "a5a4778d,refs=136", + "org.eclipse.jetty.http2:http2-hpack:10.0.22" : "a5a4778d,refs=136", + "org.eclipse.jetty.http2:http2-http-client-transport:10.0.22" : "3c6dc5ac,refs=88", + "org.eclipse.jetty.http2:http2-server:10.0.22" : "79a684e6,refs=33", + "org.eclipse.jetty.toolchain:jetty-servlet-api:4.0.6" : "0f014dd0,refs=114", + "org.eclipse.jetty:jetty-alpn-client:10.0.22" : "da1b785b,refs=134", + "org.eclipse.jetty:jetty-alpn-java-client:10.0.22" : "3c6dc5ac,refs=88", + "org.eclipse.jetty:jetty-alpn-java-server:10.0.22" : "a2e0112a,refs=31", + "org.eclipse.jetty:jetty-alpn-server:10.0.22" : "79a684e6,refs=33", + "org.eclipse.jetty:jetty-client:10.0.22" : "84863960,refs=94", "org.eclipse.jetty:jetty-deploy:10.0.22" : "24396a00,refs=4", - "org.eclipse.jetty:jetty-http:10.0.22" : "84afbb60,refs=130", - "org.eclipse.jetty:jetty-io:10.0.22" : "84afbb60,refs=130", + "org.eclipse.jetty:jetty-http:10.0.22" : "a5a4778d,refs=136", + "org.eclipse.jetty:jetty-io:10.0.22" : "a5a4778d,refs=136", "org.eclipse.jetty:jetty-jmx:10.0.22" : "24396a00,refs=4", - "org.eclipse.jetty:jetty-rewrite:10.0.22" : "5967e690,refs=32", - "org.eclipse.jetty:jetty-security:10.0.22" : "0e779887,refs=59", - "org.eclipse.jetty:jetty-server:10.0.22" : "d008b72a,refs=107", - "org.eclipse.jetty:jetty-servlet:10.0.22" : "0e779887,refs=59", + "org.eclipse.jetty:jetty-rewrite:10.0.22" : "79a684e6,refs=33", + "org.eclipse.jetty:jetty-security:10.0.22" : "b990968c,refs=61", + "org.eclipse.jetty:jetty-server:10.0.22" : "a8305aa6,refs=112", + "org.eclipse.jetty:jetty-servlet:10.0.22" : "b990968c,refs=61", "org.eclipse.jetty:jetty-servlets:10.0.22" : "24396a00,refs=4", - "org.eclipse.jetty:jetty-util:10.0.22" : "84afbb60,refs=130", + "org.eclipse.jetty:jetty-util:10.0.22" : "a5a4778d,refs=136", "org.eclipse.jetty:jetty-webapp:10.0.22" : "062c26b4,refs=7", "org.eclipse.jetty:jetty-xml:10.0.22" : "062c26b4,refs=7", "org.freemarker:freemarker:2.3.32" : "c77c5ec7,refs=1", "org.gagravarr:vorbis-java-core:0.8" : "50a667d1,refs=5", "org.gagravarr:vorbis-java-tika:0.8" : "50a667d1,refs=5", - "org.glassfish.hk2.external:aopalliance-repackaged:3.1.1" : "ad8f08d7,refs=79", - "org.glassfish.hk2:hk2-api:3.1.1" : "ad8f08d7,refs=79", - "org.glassfish.hk2:hk2-locator:3.1.1" : "ad8f08d7,refs=79", - "org.glassfish.hk2:hk2-utils:3.1.1" : "ad8f08d7,refs=79", - "org.glassfish.hk2:osgi-resource-locator:1.0.3" : "ad8f08d7,refs=79", + "org.glassfish.hk2.external:aopalliance-repackaged:3.1.1" : "30d41762,refs=83", + "org.glassfish.hk2:hk2-api:3.1.1" : "30d41762,refs=83", + "org.glassfish.hk2:hk2-locator:3.1.1" : "30d41762,refs=83", + "org.glassfish.hk2:hk2-utils:3.1.1" : "30d41762,refs=83", + "org.glassfish.hk2:osgi-resource-locator:1.0.3" : "30d41762,refs=83", "org.glassfish.jaxb:jaxb-runtime:2.3.8" : "debe9836,refs=7", "org.glassfish.jaxb:txw2:2.3.8" : "debe9836,refs=7", - "org.glassfish.jersey.containers:jersey-container-jetty-http:2.39.1" : "ad8f08d7,refs=79", - "org.glassfish.jersey.core:jersey-client:3.1.9" : "ad8f08d7,refs=79", - "org.glassfish.jersey.core:jersey-common:3.1.9" : "ad8f08d7,refs=79", - "org.glassfish.jersey.core:jersey-server:3.1.9" : "ad8f08d7,refs=79", - "org.glassfish.jersey.ext:jersey-entity-filtering:3.1.9" : "ad8f08d7,refs=79", - "org.glassfish.jersey.inject:jersey-hk2:3.1.9" : "ad8f08d7,refs=79", - "org.glassfish.jersey.media:jersey-media-json-jackson:3.1.9" : "ad8f08d7,refs=79", - "org.hamcrest:hamcrest:3.0" : "06ca9183,refs=52", + "org.glassfish.jersey.containers:jersey-container-jetty-http:2.39.1" : "30d41762,refs=83", + "org.glassfish.jersey.core:jersey-client:3.1.9" : "30d41762,refs=83", + "org.glassfish.jersey.core:jersey-common:3.1.9" : "30d41762,refs=83", + "org.glassfish.jersey.core:jersey-server:3.1.9" : "30d41762,refs=83", + "org.glassfish.jersey.ext:jersey-entity-filtering:3.1.9" : "30d41762,refs=83", + "org.glassfish.jersey.inject:jersey-hk2:3.1.9" : "30d41762,refs=83", + "org.glassfish.jersey.media:jersey-media-json-jackson:3.1.9" : "30d41762,refs=83", + "org.hamcrest:hamcrest:3.0" : "e9094088,refs=54", "org.hdrhistogram:HdrHistogram:2.1.12" : "1e12e466,refs=2", "org.hsqldb:hsqldb:2.7.2" : "970f2ee7,refs=1", "org.immutables:value-annotations:2.10.1" : "d3d191b2,refs=1", "org.itadaki:bzip2:0.9.1" : "50a667d1,refs=5", - "org.javassist:javassist:3.30.2-GA" : "ad8f08d7,refs=79", + "org.javassist:javassist:3.30.2-GA" : "30d41762,refs=83", "org.jctools:jctools-core:4.0.5" : "52ada00b,refs=4", "org.jdom:jdom2:2.0.6.1" : "50a667d1,refs=5", "org.jetbrains.kotlin:kotlin-reflect:1.8.22" : "c77c5ec7,refs=1", @@ -415,15 +416,15 @@ "org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.9.10" : "b6a343e2,refs=5", "org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.9.10" : "b6a343e2,refs=5", "org.jetbrains:annotations:13.0" : "b6a343e2,refs=5", - "org.jspecify:jspecify:1.0.0" : "e5b524d7,refs=26", - "org.junit.jupiter:junit-jupiter-api:5.6.2" : "3c9a199e,refs=29", - "org.junit.platform:junit-platform-commons:1.6.2" : "3c9a199e,refs=29", - "org.junit:junit-bom:5.6.2" : "3c9a199e,refs=29", + "org.jspecify:jspecify:1.0.0" : "a9f15c33,refs=27", + "org.junit.jupiter:junit-jupiter-api:5.6.2" : "fcbab398,refs=30", + "org.junit.platform:junit-platform-commons:1.6.2" : "fcbab398,refs=30", + "org.junit:junit-bom:5.6.2" : "fcbab398,refs=30", "org.latencyutils:LatencyUtils:2.0.3" : "7df0e72e,refs=1", "org.locationtech.jts.io:jts-io-common:1.19.0" : "93acde90,refs=6", "org.locationtech.jts:jts-core:1.19.0" : "93acde90,refs=6", "org.locationtech.proj4j:proj4j:1.2.2" : "93acde90,refs=6", - "org.locationtech.spatial4j:spatial4j:0.8" : "ad8f08d7,refs=79", + "org.locationtech.spatial4j:spatial4j:0.8" : "30d41762,refs=83", "org.lz4:lz4-java:1.8.0" : "f493e7bb,refs=7", "org.mockito:mockito-core:5.12.0" : "5f62bd8e,refs=18", "org.mockito:mockito-subclass:5.12.0" : "ef8aea8b,refs=7", @@ -431,15 +432,15 @@ "org.opengis:geoapi:3.0.1" : "50a667d1,refs=5", "org.openjdk.jmh:jmh-core:1.37" : "c718e885,refs=5", "org.openjdk.jmh:jmh-generator-annprocess:1.37" : "2d06957b,refs=1", - "org.opentest4j:opentest4j:1.2.0" : "3c9a199e,refs=29", + "org.opentest4j:opentest4j:1.2.0" : "fcbab398,refs=30", "org.osgi:org.osgi.resource:1.0.0" : "5fc760f2,refs=1", "org.osgi:org.osgi.service.serviceloader:1.0.0" : "5fc760f2,refs=1", "org.osgi:osgi.annotation:8.1.0" : "5fc760f2,refs=1", - "org.ow2.asm:asm:9.3" : "ddc123c8,refs=80", - "org.ow2.asm:asm-analysis:7.2" : "ebd3db47,refs=77", - "org.ow2.asm:asm-commons:7.2" : "ebd3db47,refs=77", - "org.ow2.asm:asm-tree:7.2" : "ebd3db47,refs=77", - "org.pcollections:pcollections:4.0.1" : "bddbe009,refs=29", + "org.ow2.asm:asm:9.3" : "73ad51d3,refs=84", + "org.ow2.asm:asm-analysis:7.2" : "428a31d2,refs=81", + "org.ow2.asm:asm-commons:7.2" : "428a31d2,refs=81", + "org.ow2.asm:asm-tree:7.2" : "428a31d2,refs=81", + "org.pcollections:pcollections:4.0.1" : "d6a20741,refs=30", "org.quicktheories:quicktheories:0.26" : "52ada00b,refs=4", "org.reactivestreams:reactive-streams:1.0.4" : "87cc13ff,refs=5", "org.rocksdb:rocksdbjni:7.9.2" : "934e1fc5,refs=4", @@ -447,10 +448,10 @@ "org.scala-lang.modules:scala-java8-compat_2.13:1.0.2" : "4bf37e93,refs=3", "org.scala-lang:scala-library:2.13.15" : "4bf37e93,refs=3", "org.scala-lang:scala-reflect:2.13.12" : "4bf37e93,refs=3", - "org.semver4j:semver4j:5.3.0" : "b57e9bf6,refs=85", - "org.slf4j:jcl-over-slf4j:2.0.13" : "a6fb6a35,refs=86", - "org.slf4j:jul-to-slf4j:2.0.13" : "58171492,refs=26", - "org.slf4j:slf4j-api:2.0.13" : "5fb053e8,refs=132", + "org.semver4j:semver4j:5.3.0" : "c2770301,refs=89", + "org.slf4j:jcl-over-slf4j:2.0.13" : "f05499c0,refs=90", + "org.slf4j:jul-to-slf4j:2.0.13" : "77b11a58,refs=27", + "org.slf4j:slf4j-api:2.0.13" : "0e228a15,refs=138", "org.springframework.boot:spring-boot:2.7.13" : "1e12e466,refs=2", "org.springframework.boot:spring-boot-actuator:2.7.13" : "1e12e466,refs=2", "org.springframework.boot:spring-boot-actuator-autoconfigure:2.7.13" : "1e12e466,refs=2", @@ -475,7 +476,7 @@ "org.tallison:metadata-extractor:2.17.1.0" : "50a667d1,refs=5", "org.threeten:threetenbp:1.6.9" : "784a94ea,refs=5", "org.tukaani:xz:1.9" : "50a667d1,refs=5", - "org.xerial.snappy:snappy-java:1.1.10.5" : "99b82a6c,refs=82", + "org.xerial.snappy:snappy-java:1.1.10.5" : "b9b86677,refs=86", "org.yaml:snakeyaml:1.30" : "1e12e466,refs=2", "software.amazon.awssdk:annotations:2.26.19" : "87cc13ff,refs=5", "software.amazon.awssdk:apache-client:2.26.19" : "87cc13ff,refs=5", @@ -524,60 +525,30 @@ "projectPath" : ":solr:modules:opentelemetry" } ], - "062c26b4" : [ - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" - }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:server" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" - }, + "01b4f802" : [ { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "projectPath" : ":solr:api" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "06ca9183" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:benchmark" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" }, { "configuration" : "testCompileClasspath", @@ -588,7 +559,15 @@ "projectPath" : ":solr:core" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, { @@ -596,7 +575,7 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, { @@ -604,8 +583,12 @@ "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { "configuration" : "testRuntimeClasspath", @@ -619,40 +602,36 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "compileClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:analysis-extras" }, { @@ -660,7 +639,15 @@ "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, { @@ -668,7 +655,15 @@ "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, { @@ -676,454 +671,496 @@ "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testCompileClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "0769b123" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - } - ], - "08ef8dc6" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:sql" + } + ], + "062c26b4" : [ + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:server" + }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:server" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:solrj" }, { "configuration" : "serverLib", "projectPath" : ":solr:webapp" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "067b0200" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:api" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:api" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:core" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:core" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "0a82b27c" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "compileClasspath", @@ -1137,6 +1174,10 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:extraction" @@ -1157,6 +1198,10 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -1165,269 +1210,237 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - } - ], - "0d28f997" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - } - ], - "0e779887" : [ { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:server" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" - }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testCompileClasspath", @@ -1438,19 +1451,29 @@ "projectPath" : ":solr:modules:sql" } ], - "100652ac" : [ + "0769b123" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + } + ], + "079d20a6" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -1483,10 +1506,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -1499,34 +1518,14 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" @@ -1544,39 +1543,27 @@ "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "compileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, - { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:test-framework" }, { @@ -1635,10 +1622,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -1651,18 +1634,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -1675,18 +1650,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -1699,10 +1666,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -1723,10 +1686,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -1739,10 +1698,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -1808,12 +1763,24 @@ "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -1831,10 +1798,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -1848,15 +1811,77 @@ "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" + } + ], + "0a82b27c" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" } ], - "1069c1cc" : [ + "0bb51e54" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -1869,10 +1894,34 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" @@ -1881,6 +1930,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" @@ -1890,7 +1943,7 @@ "projectPath" : ":solr:server" }, { - "configuration" : "serverLib", + "configuration" : "solrCore", "projectPath" : ":solr:server" }, { @@ -1918,111 +1971,113 @@ "projectPath" : ":solr:test-framework" }, { - "configuration" : "serverLib", + "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "1640bbba" : [ - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" @@ -2032,53 +2087,165 @@ "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" } ], - "1643ad05" : [ + "0d28f997" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:opentelemetry" } ], - "17e13daa" : [ + "0e228a15" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:api" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:api" @@ -2147,6 +2314,18 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" @@ -2159,10 +2338,18 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "libExt", + "projectPath" : ":solr:server" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:server" + }, { "configuration" : "solrCore", "projectPath" : ":solr:server" @@ -2175,6 +2362,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj" @@ -2183,6 +2378,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-streaming" @@ -2191,6 +2394,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-zookeeper" @@ -2215,6 +2426,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -2507,6 +2722,30 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:scripting" @@ -2556,7 +2795,7 @@ "projectPath" : ":solr:modules:sql" } ], - "1b72eeae" : [ + "0f014dd0" : [ { "configuration" : "testCompileClasspath", "projectPath" : ":solr:api" @@ -2625,18 +2864,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" @@ -2653,6 +2880,10 @@ "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:server" + }, { "configuration" : "solrCore", "projectPath" : ":solr:server" @@ -2665,14 +2896,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" - }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj" @@ -2681,14 +2904,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-streaming" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-streaming" @@ -2697,14 +2912,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-zookeeper" @@ -2730,12 +2937,12 @@ "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrCore", + "configuration" : "serverLib", "projectPath" : ":solr:webapp" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { "configuration" : "runtimeClasspath", @@ -2757,10 +2964,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:clustering" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -2781,10 +2984,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -2805,10 +3004,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -2829,10 +3024,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -2877,10 +3068,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -2925,10 +3112,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:langid" @@ -2950,11 +3133,7 @@ "projectPath" : ":solr:modules:langid" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "runtimeClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:ltr" }, { @@ -2973,10 +3152,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -2997,10 +3172,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -3022,8 +3193,24 @@ "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -3045,10 +3232,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -3070,17 +3253,7 @@ "projectPath" : ":solr:modules:sql" } ], - "1e12e466" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "1f5bde05" : [ + "157928e7" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -3093,10 +3266,34 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" @@ -3105,20 +3302,36 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "libExt", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" }, { - "configuration" : "runtimeClasspath", + "configuration" : "solrCore", "projectPath" : ":solr:server" }, { @@ -3154,9 +3367,17 @@ "projectPath" : ":solr:test-framework" }, { - "configuration" : "serverLib", + "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:analysis-extras" @@ -3165,6 +3386,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" @@ -3173,6 +3402,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" @@ -3181,6 +3418,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" @@ -3189,6 +3434,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" @@ -3197,6 +3450,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" @@ -3205,14 +3466,38 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" @@ -3221,6 +3506,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:langid" @@ -3229,6 +3522,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" @@ -3237,6 +3538,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" @@ -3245,6 +3554,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:s3-repository" @@ -3253,27 +3570,37 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "20f1e0e0" : [ + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", @@ -3283,30 +3610,52 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:sql" }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "21136b15" : [ + "1643ad05" : [ { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + } + ], + "1adb38f7" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:api" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:api" }, { "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, { @@ -3333,6 +3682,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -3346,11 +3699,31 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testCompileClasspath", "projectPath" : ":solr:prometheus-exporter" }, { @@ -3369,26 +3742,34 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" - }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:solrj" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:solrj" }, { "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "runtimeClasspath", "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" @@ -3477,6 +3858,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -3489,10 +3874,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -3505,6 +3898,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -3525,6 +3922,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -3537,6 +3938,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -3601,98 +4006,84 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "23e8a2eb" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - } - ], - "24396a00" : [ - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" - } - ], - "26b9da63" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:sql" } ], - "27f62655" : [ + "1bda69a3" : [ + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" @@ -3701,6 +4092,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:core" + }, { "configuration" : "compileClasspath", "projectPath" : ":solr:core" @@ -3721,6 +4116,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -3737,16 +4136,36 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "libExt", + "configuration" : "annotationProcessor", "projectPath" : ":solr:server" }, { @@ -3757,22 +4176,42 @@ "configuration" : "solrCore", "projectPath" : ":solr:server" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solr-ref-guide" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-streaming" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-zookeeper" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:test-framework" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" @@ -3782,13 +4221,17 @@ "projectPath" : ":solr:test-framework" }, { - "configuration" : "serverLib", + "configuration" : "annotationProcessor", "projectPath" : ":solr:webapp" }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -3805,6 +4248,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -3821,6 +4268,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -3837,6 +4288,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -3853,6 +4308,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -3869,6 +4328,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -3885,6 +4348,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -3897,10 +4368,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -3917,6 +4396,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:langid" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:langid" @@ -3933,6 +4416,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:ltr" @@ -3949,6 +4436,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -3965,6 +4456,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -3981,186 +4476,140 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "280cfec8" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - } - ], - "2d06957b" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" - } - ], - "322f4a3c" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:core" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:server" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "1e12e466" : [ { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "20f1e0e0" : [ { - "configuration" : "annotationProcessor", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-zookeeper" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:test-framework" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:webapp" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hadoop-auth" - }, + "projectPath" : ":solr:modules:sql" + } + ], + "23e8a2eb" : [ { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:langid" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:ltr" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + } + ], + "24396a00" : [ { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" + "configuration" : "serverLib", + "projectPath" : ":solr:server" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" } ], - "36393977" : [ + "25903e1d" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -4209,6 +4658,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" @@ -4217,6 +4674,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "libExt", + "projectPath" : ":solr:server" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -4229,10 +4690,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" @@ -4245,14 +4702,26 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -4305,10 +4774,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -4321,10 +4786,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -4373,10 +4834,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -4461,6 +4918,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -4494,229 +4967,171 @@ "projectPath" : ":solr:modules:sql" } ], - "3b210678" : [ + "26b9da63" : [ { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, + "projectPath" : ":solr:modules:hdfs" + } + ], + "27d9a2c5" : [ { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:api" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "3c9a199e" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, { - "configuration" : "testCompileClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:core" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "compileClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "3ff3bc39" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" - }, - { - "configuration" : "solrCore", - "projectPath" : ":solr:server" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:test-framework" }, { @@ -4727,6 +5142,10 @@ "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -4739,6 +5158,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -4767,6 +5190,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -4779,10 +5206,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -4795,10 +5230,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -4811,10 +5254,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -4827,10 +5278,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -4843,10 +5302,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -4859,10 +5326,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:langid" @@ -4875,10 +5350,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:langid" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:ltr" @@ -4891,10 +5374,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -4907,10 +5398,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -4923,52 +5422,102 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "420fd813" : [ + "280cfec8" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + } + ], + "28c7d4d7" : [ { "configuration" : "testCompileClasspath", "projectPath" : ":solr:api" @@ -5037,18 +5586,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" @@ -5061,6 +5598,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "libExt", + "projectPath" : ":solr:server" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -5077,14 +5618,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" - }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj" @@ -5093,14 +5626,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-streaming" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-streaming" @@ -5109,14 +5634,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-zookeeper" @@ -5141,6 +5658,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -5433,6 +5954,30 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:scripting" @@ -5482,45 +6027,25 @@ "projectPath" : ":solr:modules:sql" } ], - "4985a322" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - } - ], - "4bf37e93" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, + "2a08a891" : [ { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - } - ], - "4ce82561" : [ + "projectPath" : ":solr:api" + }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:benchmark" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:benchmark" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, { @@ -5571,10 +6096,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:prometheus-exporter" @@ -5604,16 +6125,12 @@ "projectPath" : ":solr:server" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "testCompileClasspath", @@ -5624,25 +6141,41 @@ "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" @@ -5651,6 +6184,10 @@ "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -5663,10 +6200,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -5679,10 +6224,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -5695,6 +6248,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -5723,6 +6280,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -5735,10 +6296,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -5751,10 +6320,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -5767,10 +6344,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -5791,6 +6376,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:langid" @@ -5803,10 +6392,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:langid" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:ltr" @@ -5819,10 +6416,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -5835,10 +6440,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -5859,134 +6472,140 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "4f81d786" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - } - ], - "50a667d1" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:sql" } ], - "515616b6" : [ + "2d06957b" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" + } + ], + "2d7a8cd1" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:core" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - } - ], - "52ada00b" : [ + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - } - ], - "58171492" : [ + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, { @@ -5998,225 +6617,283 @@ "projectPath" : ":solr:server" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" - } - ], - "5967e690" : [ { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "5b11e899" : [ + "30d41762" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -6357,10 +7034,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -6373,10 +7046,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -6509,6 +7178,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -6542,19 +7227,11 @@ "projectPath" : ":solr:modules:sql" } ], - "5b2db4f4" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:api" - }, + "370d61de" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" @@ -6563,10 +7240,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:core" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:core" @@ -6588,7 +7261,7 @@ "projectPath" : ":solr:core" }, { - "configuration" : "annotationProcessor", + "configuration" : "compileClasspath", "projectPath" : ":solr:cross-dc-manager" }, { @@ -6604,39 +7277,23 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", + "configuration" : "libExt", "projectPath" : ":solr:server" }, { @@ -6647,42 +7304,22 @@ "configuration" : "solrCore", "projectPath" : ":solr:server" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solr-ref-guide" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-streaming" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-zookeeper" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:test-framework" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" @@ -6692,17 +7329,13 @@ "projectPath" : ":solr:test-framework" }, { - "configuration" : "annotationProcessor", + "configuration" : "serverLib", "projectPath" : ":solr:webapp" }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:analysis-extras" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -6719,10 +7352,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:clustering" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -6739,10 +7368,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -6759,10 +7384,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -6779,10 +7400,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -6799,10 +7416,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -6819,14 +7432,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -6839,18 +7444,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -6867,10 +7464,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:langid" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:langid" @@ -6887,10 +7480,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:ltr" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:ltr" @@ -6907,10 +7496,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:opentelemetry" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -6927,10 +7512,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:s3-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -6948,8 +7529,20 @@ "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -6967,10 +7560,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -6988,169 +7577,41 @@ "projectPath" : ":solr:modules:sql" } ], - "5d98342f" : [ + "3b210678" : [ { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, + "projectPath" : ":solr:modules:s3-repository" + } + ], + "3c6dc5ac" : [ { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:api" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "5e82f1c0" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "compileClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -7159,18 +7620,10 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:core" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -7184,19 +7637,19 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "runtimeLibs", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testCompileClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, { @@ -7207,21 +7660,21 @@ "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:server" - }, { "configuration" : "solrCore", "projectPath" : ":solr:server" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "testCompileClasspath", @@ -7232,7 +7685,7 @@ "projectPath" : ":solr:solrj" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:solrj-streaming" }, { @@ -7240,33 +7693,21 @@ "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" - }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -7283,10 +7724,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:analysis-extras" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -7303,10 +7740,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -7323,10 +7756,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -7343,10 +7772,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -7363,18 +7788,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -7387,10 +7804,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -7407,18 +7820,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -7431,10 +7836,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -7451,10 +7852,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:langid" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" @@ -7471,10 +7868,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" @@ -7491,10 +7884,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -7512,12 +7901,24 @@ "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -7531,10 +7932,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -7551,144 +7948,24 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "5f4312f3" : [ + "428a31d2" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - } - ], - "5f62bd8e" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "5fb053e8" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -7697,18 +7974,10 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:core" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -7721,138 +7990,54 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, - { - "configuration" : "libExt", - "projectPath" : ":solr:server" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:server" - }, { "configuration" : "solrCore", "projectPath" : ":solr:server" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-streaming" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" - }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -7865,18 +8050,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:analysis-extras" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:clustering" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -7889,18 +8066,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -7913,18 +8082,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -7937,18 +8098,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -7961,18 +8114,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -7985,18 +8130,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -8010,17 +8147,9 @@ "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -8033,18 +8162,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:langid" @@ -8057,18 +8178,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:langid" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:ltr" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:ltr" @@ -8081,18 +8194,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -8105,18 +8210,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -8130,16 +8227,24 @@ "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -8153,18 +8258,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -8177,136 +8274,112 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "5fc760f2" : [ + "4985a322" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" } ], - "5fcc0587" : [ + "4bf37e93" : [ { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:cross-dc-manager" } ], - "6351de37" : [ + "4f81d786" : [ { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + } + ], + "50a667d1" : [ { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" - }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + } + ], + "515616b6" : [ { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" } ], - "69bf1b73" : [ + "52ada00b" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:benchmark" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:benchmark" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:benchmark" } ], - "6a8501ec" : [ + "5331c7d2" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -8339,10 +8412,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -8355,34 +8424,14 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" @@ -8399,34 +8448,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" @@ -8515,10 +8544,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -8531,18 +8556,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -8555,10 +8572,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -8591,10 +8604,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -8667,6 +8676,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -8683,10 +8708,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -8699,160 +8720,20 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "6ac4140f" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "libExt", - "projectPath" : ":solr:server" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" - }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" } ], - "6fb73f3a" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - } - ], - "703dff64" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" - }, + "54caaa1f" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" @@ -8877,10 +8758,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -8893,10 +8770,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -8914,12 +8787,12 @@ "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "libExt", + "projectPath" : ":solr:server" }, { "configuration" : "runtimeClasspath", @@ -8929,42 +8802,18 @@ "configuration" : "solrCore", "projectPath" : ":solr:server" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" @@ -8986,12 +8835,12 @@ "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrCore", + "configuration" : "serverLib", "projectPath" : ":solr:webapp" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { "configuration" : "runtimeClasspath", @@ -9005,18 +8854,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:analysis-extras" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:clustering" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -9029,18 +8870,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -9053,10 +8886,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -9085,10 +8914,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -9101,18 +8926,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -9125,18 +8942,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -9149,18 +8958,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -9173,18 +8974,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:langid" @@ -9197,18 +8990,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:langid" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:ltr" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:ltr" @@ -9221,18 +9006,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -9246,17 +9023,9 @@ "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -9270,16 +9039,24 @@ "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -9293,18 +9070,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -9317,416 +9086,324 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "727aea63" : [ + "5f4312f3" : [ { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:hdfs" } ], - "72c9c512" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, + "5f62bd8e" : [ { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "compileClasspath", "projectPath" : ":solr:core" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" - }, + "projectPath" : ":solr:modules:s3-repository" + } + ], + "5fc760f2" : [ { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + } + ], + "5fcc0587" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, + "projectPath" : ":solr:modules:opentelemetry" + } + ], + "69bf1b73" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:langid" + } + ], + "6ac2c5f8" : [ + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:core" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:server" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:webapp" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "runtimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" + } + ], + "6fb73f3a" : [ { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" - }, + "projectPath" : ":solr:modules:gcs-repository" + } + ], + "727aea63" : [ { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "7413b098" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" - }, + "73ad51d3" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -9735,18 +9412,10 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:core" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -9759,34 +9428,14 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" @@ -9799,58 +9448,26 @@ "configuration" : "solrCore", "projectPath" : ":solr:server" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" @@ -9859,10 +9476,6 @@ "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -9875,18 +9488,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:analysis-extras" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:clustering" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -9899,18 +9504,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -9923,10 +9520,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -9955,10 +9548,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -9971,18 +9560,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -9995,18 +9576,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -10019,18 +9592,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -10051,10 +9616,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:langid" @@ -10067,20 +9628,12 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:langid" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "runtimeClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:ltr" }, { @@ -10091,18 +9644,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -10115,18 +9660,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -10140,16 +9677,24 @@ "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -10163,18 +9708,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -10188,169 +9725,191 @@ "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" + } + ], + "761c3c3c" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" } ], - "7498dc3d" : [ + "762fd911" : [ { - "configuration" : "annotationProcessor", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" }, { - "configuration" : "annotationProcessor", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, { - "configuration" : "annotationProcessor", + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, { - "configuration" : "annotationProcessor", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "libExt", + "projectPath" : ":solr:server" }, { - "configuration" : "annotationProcessor", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" }, { - "configuration" : "annotationProcessor", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "annotationProcessor", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-streaming" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "annotationProcessor", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "annotationProcessor", + "configuration" : "compileClasspath", "projectPath" : ":solr:test-framework" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:webapp" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:extraction" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "annotationProcessor", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "annotationProcessor", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "annotationProcessor", + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeLibs", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" }, { @@ -10358,31 +9917,31 @@ "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, { @@ -10390,329 +9949,313 @@ "projectPath" : ":solr:modules:sql" } ], - "761c3c3c" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, + "778d978f" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - } - ], - "76db8e26" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:benchmark" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:benchmark" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" - }, + } + ], + "77b11a58" : [ { - "configuration" : "runtimeLibs", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "libExt", + "projectPath" : ":solr:server" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + } + ], + "781655d3" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + } + ], + "784a94ea" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:gcs-repository" + } + ], + "79a684e6" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "serverLib", + "projectPath" : ":solr:server" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "7accccef" : [ { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -10722,109 +10265,103 @@ "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" - }, + } + ], + "7df0e72e" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" + } + ], + "7ebc5830" : [ + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "libExt", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "778d978f" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - } - ], - "781655d3" : [ + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, { - "configuration" : "compileClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" - } - ], - "784a94ea" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" } ], - "78dd58c9" : [ + "84863960" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -10873,6 +10410,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" @@ -10893,14 +10438,34 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" @@ -10997,6 +10562,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -11009,6 +10578,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -11029,6 +10602,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -11041,6 +10618,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -11106,12 +10687,24 @@ "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -11146,29 +10739,27 @@ "projectPath" : ":solr:modules:sql" } ], - "7accccef" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, + "84b99a57" : [ { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "7bb67147" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" @@ -11193,6 +10784,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -11205,6 +10800,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -11213,6 +10812,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" @@ -11225,26 +10828,50 @@ "configuration" : "solrCore", "projectPath" : ":solr:server" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" @@ -11253,6 +10880,10 @@ "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -11265,10 +10896,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -11281,10 +10920,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -11297,6 +10944,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -11325,6 +10976,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -11337,10 +10992,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -11353,10 +11016,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -11369,10 +11040,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -11385,12 +11064,20 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:langid" }, { @@ -11401,10 +11088,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:langid" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:ltr" @@ -11417,10 +11112,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -11433,10 +11136,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -11457,6 +11168,34 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -11469,10 +11208,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -11486,17 +11233,15 @@ "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:sql" - } - ], - "7df0e72e" : [ + }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:sql" } ], - "7f2dd9d5" : [ + "87874129" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -11510,1133 +11255,1131 @@ "projectPath" : ":solr:benchmark" }, { - "configuration" : "compileClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:core" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:sql" + } + ], + "87cc13ff" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:s3-repository" + } + ], + "8ba2f0f7" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + } + ], + "8d0cef4c" : [ { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, + "projectPath" : ":solr:modules:sql" + } + ], + "90aa62e6" : [ { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "runtimeLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" + } + ], + "90ad3802" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:benchmark" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:core" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "84afbb60" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" - }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "934e1fc5" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:cross-dc-manager" + } + ], + "93acde90" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, + "projectPath" : ":solr:modules:sql" + } + ], + "970f2ee7" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + } + ], + "987aa92c" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:api" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:api" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:benchmark" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:core" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:core" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:solrj" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "87cc13ff" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "87cd582a" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:sql" + } + ], + "98f116c7" : [ + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:core" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:server" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:webapp" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "compileClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeLibs", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:extraction" }, { @@ -12648,19 +12391,19 @@ "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "compileClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeLibs", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:gcs-repository" }, { @@ -12672,223 +12415,113 @@ "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" - }, + "projectPath" : ":solr:modules:sql" + } + ], + "9bcc8206" : [ { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:jwt-auth" } ], - "8b517977" : [ + "9e7d4624" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -12957,10 +12590,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" @@ -13033,6 +12662,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -13045,6 +12678,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -13174,12 +12811,24 @@ "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -13214,151 +12863,199 @@ "projectPath" : ":solr:modules:sql" } ], - "8ba2f0f7" : [ + "9e97e18c" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" } ], - "8d0cef4c" : [ + "a2e0112a" : [ { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:api" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "serverLib", + "projectPath" : ":solr:server" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "90aa62e6" : [ + "projectPath" : ":solr:solrj" + }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - } - ], - "934e1fc5" : [ + "projectPath" : ":solr:solrj-zookeeper" + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - } - ], - "93acde90" : [ + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "970f2ee7" : [ + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" } ], - "99b82a6c" : [ + "a5a4778d" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -13375,6 +13072,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -13387,14 +13088,34 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" @@ -13403,22 +13124,66 @@ "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:server" + }, { "configuration" : "solrCore", "projectPath" : ":solr:server" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" @@ -13439,10 +13204,18 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -13455,10 +13228,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -13471,10 +13252,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -13487,10 +13276,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -13503,10 +13300,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -13519,10 +13324,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -13535,6 +13348,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -13563,6 +13380,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -13575,10 +13396,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:langid" @@ -13591,10 +13420,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:langid" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:ltr" @@ -13607,10 +13444,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -13623,10 +13468,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -13639,28 +13492,68 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "runtimeClasspath", + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" }, { @@ -13671,104 +13564,150 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "9bcc8206" : [ + "a5b348ef" : [ { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:hadoop-auth" } ], - "9e97e18c" : [ + "a6a1e3c5" : [ { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:sql" + } + ], + "a7f96198" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:gcs-repository" } ], - "a05ffa28" : [ + "a8305aa6" : [ { "configuration" : "testCompileClasspath", "projectPath" : ":solr:api" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, { "configuration" : "compileClasspath", "projectPath" : ":solr:benchmark" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:benchmark" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, { "configuration" : "compileClasspath", "projectPath" : ":solr:core" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:core" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" + }, { "configuration" : "compileClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -13781,6 +13720,10 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -13789,40 +13732,96 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:server" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:server" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solr-ref-guide" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-zookeeper" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, { "configuration" : "compileClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:test-framework" }, { - "configuration" : "compileClasspath", + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:analysis-extras" }, { @@ -13830,7 +13829,19 @@ "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "compileClasspath", + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, { @@ -13838,7 +13849,19 @@ "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "compileClasspath", + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, { @@ -13846,7 +13869,19 @@ "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "compileClasspath", + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, { @@ -13854,8 +13889,8 @@ "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", @@ -13865,6 +13900,10 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -13874,306 +13913,502 @@ "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "compileClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "a5b348ef" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - } - ], - "a6a1e3c5" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "a6fb6a35" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:sql" + } + ], + "a9f15c33" : [ + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:core" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:server" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" + } + ], + "aa7a59c6" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + } + ], + "aac12aa0" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:server" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "solrPlatformLibs", @@ -14315,6 +14550,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -14348,266 +14599,126 @@ "projectPath" : ":solr:modules:sql" } ], - "a7f96198" : [ + "abf04837" : [ { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:benchmark" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:core" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - } - ], - "a9dcee72" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:api" + "projectPath" : ":solr:core" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:core" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", + "configuration" : "runtimeLibs", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:server" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solr-ref-guide" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-streaming" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-zookeeper" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:test-framework" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:webapp" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:ltr" + "configuration" : "compileClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" - } - ], - "aa7a59c6" : [ { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - } - ], - "acc31ef6" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - } - ], - "ad8f08d7" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:solrj" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:solrj" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:solrj" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" - }, - { - "configuration" : "solrCore", - "projectPath" : ":solr:server" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testRuntimeClasspath", @@ -14673,6 +14784,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -14685,10 +14800,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -14701,10 +14824,18 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -14717,6 +14848,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -14749,6 +14884,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -14813,10 +14952,30 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -14833,6 +14992,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -14845,43 +15008,165 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "b3b7541b" : [ + "acc31ef6" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + } + ], + "afdb2998" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:saved-search" + } + ], + "b4755bf3" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "b48c15dd" : [ + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:core" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", @@ -14895,18 +15180,42 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:server" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -14915,22 +15224,66 @@ "configuration" : "solrCore", "projectPath" : ":solr:server" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:test-framework" + }, { "configuration" : "compileClasspath", "projectPath" : ":solr:test-framework" @@ -14947,10 +15300,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:webapp" + }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -14963,10 +15328,22 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -14979,10 +15356,22 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -14995,10 +15384,22 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -15011,10 +15412,22 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -15027,10 +15440,22 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -15043,28 +15468,52 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "runtimeLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "runtimeClasspath", + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, { @@ -15075,10 +15524,22 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:langid" @@ -15091,10 +15552,22 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:langid" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:ltr" @@ -15107,10 +15580,22 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -15123,10 +15608,22 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -15139,10 +15636,50 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -15155,10 +15692,22 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -15171,68 +15720,98 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "b4755bf3" : [ + "b6a343e2" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + } + ], + "b6f115a3" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:langid" } ], - "b57e9bf6" : [ + "b990968c" : [ { - "configuration" : "compileClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:api" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:benchmark" }, { @@ -15240,16 +15819,16 @@ "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:core" }, { - "configuration" : "runtimeLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", @@ -15264,19 +15843,15 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:prometheus-exporter" }, { @@ -15288,15 +15863,19 @@ "projectPath" : ":solr:server" }, { - "configuration" : "solrCore", + "configuration" : "serverLib", "projectPath" : ":solr:server" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj" }, { @@ -15304,7 +15883,7 @@ "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-streaming" }, { @@ -15312,7 +15891,7 @@ "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-zookeeper" }, { @@ -15320,27 +15899,27 @@ "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:test-framework" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:analysis-extras" }, { @@ -15348,15 +15927,7 @@ "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:clustering" }, { @@ -15364,15 +15935,7 @@ "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:cross-dc" }, { @@ -15380,31 +15943,15 @@ "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:gcs-repository" }, { @@ -15412,15 +15959,7 @@ "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, { @@ -15428,15 +15967,7 @@ "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:hdfs" }, { @@ -15444,15 +15975,7 @@ "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:jwt-auth" }, { @@ -15460,15 +15983,7 @@ "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:langid" }, { @@ -15476,15 +15991,7 @@ "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:ltr" }, { @@ -15492,15 +15999,7 @@ "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:opentelemetry" }, { @@ -15508,119 +16007,39 @@ "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "b6a343e2" : [ { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - } - ], - "b6f115a3" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:sql" } ], - "bc8e8214" : [ + "b9b86677" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -15633,10 +16052,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -15669,14 +16084,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" @@ -15685,10 +16092,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, - { - "configuration" : "libExt", - "projectPath" : ":solr:server" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -15729,10 +16132,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" - }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -15785,10 +16184,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -15801,10 +16196,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -15841,6 +16232,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -15853,6 +16248,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -15937,6 +16336,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -15970,29 +16385,25 @@ "projectPath" : ":solr:modules:sql" } ], - "bddbe009" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:api" - }, + "baa40a7b" : [ { - "configuration" : "annotationProcessor", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "annotationProcessor", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeLibs", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, { @@ -16000,91 +16411,91 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "libExt", + "projectPath" : ":solr:server" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:test-framework" - }, - { - "configuration" : "annotationProcessor", + "configuration" : "serverLib", "projectPath" : ":solr:webapp" }, { - "configuration" : "annotationProcessor", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "annotationProcessor", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "annotationProcessor", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "annotationProcessor", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "annotationProcessor", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "annotationProcessor", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "annotationProcessor", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "annotationProcessor", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "annotationProcessor", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "annotationProcessor", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" } ], @@ -16110,153 +16521,15 @@ "projectPath" : ":solr:modules:hadoop-auth" } ], - "c1e4e901" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - } - ], - "c6acb8a9" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - } - ], - "c718e885" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - } - ], - "c77c5ec7" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - } - ], - "cef2dbfe" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - } - ], - "d008b72a" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" - }, + "bf5445e0" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" @@ -16281,10 +16554,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -16297,10 +16566,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -16309,70 +16574,42 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "runtimeClasspath", + "configuration" : "libExt", "projectPath" : ":solr:server" }, { - "configuration" : "serverLib", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" }, { "configuration" : "solrCore", "projectPath" : ":solr:server" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" @@ -16397,10 +16634,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:analysis-extras" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -16417,10 +16650,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -16437,10 +16666,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -16457,10 +16682,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -16477,10 +16698,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -16497,10 +16714,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -16517,10 +16730,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -16537,10 +16746,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -16557,10 +16762,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:langid" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" @@ -16577,10 +16778,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" @@ -16597,10 +16794,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -16618,12 +16811,24 @@ "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -16637,10 +16842,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -16658,21 +16859,41 @@ "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" + } + ], + "c1e4e901" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:opentelemetry" } ], - "d3d191b2" : [ + "c2770301" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "dc28f153" : [ + "projectPath" : ":solr:api" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -16685,10 +16906,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -16697,18 +16914,10 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:core" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -16722,24 +16931,24 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "runtimeLibs", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", @@ -16753,14 +16962,26 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" @@ -16773,10 +16994,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" - }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -16973,6 +17190,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -17006,33 +17239,93 @@ "projectPath" : ":solr:modules:sql" } ], - "dd724fae" : [ + "c6acb8a9" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:cross-dc" + } + ], + "c718e885" : [ + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + } + ], + "c77c5ec7" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" } ], - "ddc123c8" : [ + "caaf5d31" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -17045,6 +17338,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -17053,6 +17350,10 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:core" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" @@ -17073,6 +17374,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" @@ -17093,14 +17402,26 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" @@ -17165,10 +17486,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -17181,10 +17498,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -17249,10 +17562,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -17321,6 +17630,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -17354,37 +17679,41 @@ "projectPath" : ":solr:modules:sql" } ], - "debe9836" : [ + "cef2dbfe" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:opentelemetry" } ], - "e19ba4dc" : [ + "d10c49c4" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -17434,23 +17763,7 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "testCompileClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, { @@ -17481,18 +17794,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" @@ -17517,6 +17822,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -17529,6 +17838,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -17597,10 +17910,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -17613,10 +17922,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -17701,6 +18006,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -17734,25 +18055,95 @@ "projectPath" : ":solr:modules:sql" } ], - "e2f3f42e" : [ + "d3cf8553" : [ + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "libExt", + "projectPath" : ":solr:server" + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + } + ], + "d3d191b2" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" } ], - "e5b524d7" : [ + "d6a20741" : [ { "configuration" : "annotationProcessor", "projectPath" : ":solr:api" @@ -17769,6 +18160,18 @@ "configuration" : "annotationProcessor", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "annotationProcessor", "projectPath" : ":solr:prometheus-exporter" @@ -17851,96 +18254,18 @@ }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" - } - ], - "e6d93f27" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:sql" } ], - "e80f7a3a" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:api" - }, + "da1b785b" : [ { "configuration" : "testCompileClasspath", "projectPath" : ":solr:api" @@ -17949,10 +18274,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:benchmark" @@ -17969,10 +18290,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:core" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:core" @@ -17993,10 +18310,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -18022,7 +18335,7 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", + "configuration" : "compileClasspath", "projectPath" : ":solr:prometheus-exporter" }, { @@ -18045,10 +18358,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:server" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -18057,10 +18366,6 @@ "configuration" : "solrCore", "projectPath" : ":solr:server" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solr-ref-guide" - }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solr-ref-guide" @@ -18070,7 +18375,11 @@ "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "annotationProcessor", + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "runtimeClasspath", "projectPath" : ":solr:solrj" }, { @@ -18082,20 +18391,20 @@ "projectPath" : ":solr:solrj" }, { - "configuration" : "annotationProcessor", + "configuration" : "compileClasspath", "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "compileClasspath", @@ -18113,10 +18422,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:test-framework" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:test-framework" @@ -18133,18 +18438,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:webapp" - }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:analysis-extras" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -18169,10 +18466,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:clustering" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:clustering" @@ -18197,10 +18490,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -18225,10 +18514,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:extraction" @@ -18253,10 +18538,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -18281,10 +18562,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -18309,10 +18586,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:hdfs" @@ -18337,10 +18610,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -18365,10 +18634,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:langid" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:langid" @@ -18393,10 +18658,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:ltr" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:ltr" @@ -18421,10 +18682,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:opentelemetry" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -18449,10 +18706,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:s3-repository" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -18478,8 +18731,28 @@ "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "compileClasspath", @@ -18505,10 +18778,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:sql" @@ -18534,47 +18803,81 @@ "projectPath" : ":solr:modules:sql" } ], - "e972cbed" : [ + "dd724fae" : [ { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:opentelemetry" } ], - "e9990913" : [ + "debe9836" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" } ], - "ebd3db47" : [ + "e2f3f42e" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "e5144e73" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -18587,6 +18890,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -18595,10 +18902,18 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:core" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -18611,14 +18926,34 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" @@ -18635,14 +18970,34 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" @@ -18707,6 +19062,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -18719,6 +19078,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -18783,6 +19146,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -18847,10 +19214,30 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -18867,6 +19254,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -18879,136 +19270,502 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "ef8aea8b" : [ + "e6d93f27" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "f493e7bb" : [ + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "e9094088" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testCompileClasspath", "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" } ], - "f5acb352" : [ + "e972cbed" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + } + ], + "e9990913" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, { "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + } + ], + "ecbbe36e" : [ + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:core" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:server" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" - } - ], - "f7508386" : [ + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:saved-search" + }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" } ], - "f83d8628" : [ + "ece6e856" : [ { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:api" }, { - "configuration" : "runtimeClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:benchmark" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:benchmark" }, { "configuration" : "compileClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" - }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "compileClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -19021,10 +19778,6 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -19033,157 +19786,73 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" - }, - { - "configuration" : "solrCore", - "projectPath" : ":solr:server" - }, - { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:solr-ref-guide" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" - }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, - { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:test-framework" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", @@ -19194,7 +19863,7 @@ "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:gcs-repository" }, { @@ -19202,47 +19871,23 @@ "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:jwt-auth" }, { @@ -19250,119 +19895,93 @@ "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "runtimeClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "runtimeClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "runtimeLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "ef8aea8b" : [ { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:core" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:s3-repository" } ], - "f9ff6c21" : [ + "f05499c0" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -19419,6 +20038,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "libExt", + "projectPath" : ":solr:server" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -19431,18 +20054,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:solrj" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" @@ -19471,6 +20086,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -19523,6 +20142,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -19535,6 +20158,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -19667,6 +20294,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -19700,29 +20343,59 @@ "projectPath" : ":solr:modules:sql" } ], - "fa7556ff" : [ + "f493e7bb" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + } + ], + "f5acb352" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:clustering" } ], - "fed35e7f" : [ + "f725590a" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -20119,6 +20792,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -20151,6 +20840,160 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } + ], + "f7508386" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + } + ], + "fa7556ff" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + } + ], + "fcbab398" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } ] } } \ No newline at end of file