From bba41917b8a5f28510a36f31b2ea47acf45acc91 Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Fri, 29 Mar 2024 23:18:21 -0400 Subject: [PATCH 01/85] integrate lucene-monitor into solr --- settings.gradle | 1 + solr/modules/monitor/build.gradle | 33 + .../lucene/monitor/AggregatingMatcher.java | 63 + .../monitor/CollectingMatcherProxy.java | 62 + .../lucene/monitor/DocumentBatchVisitor.java | 64 + .../apache/lucene/monitor/MatcherProxy.java | 34 + .../lucene/monitor/MonitorDataValues.java | 84 ++ .../apache/lucene/monitor/MonitorFields.java | 34 + .../org/apache/lucene/monitor/QCEVisitor.java | 73 + .../monitor/QueryTermFilterVisitor.java | 39 + .../lucene/monitor/SimpleMatcherProxy.java | 43 + .../lucene/monitor/SingleMatchConsumer.java | 27 + .../apache/solr/monitor/MonitorConstants.java | 35 + .../solr/monitor/MonitorSchemaFields.java | 55 + .../solr/monitor/PresearcherFactory.java | 45 + .../solr/monitor/SimpleQueryParser.java | 148 ++ .../solr/monitor/SolrMonitorQueryDecoder.java | 45 + .../solr/monitor/cache/MonitorQueryCache.java | 36 + .../monitor/cache/SharedMonitorCache.java | 316 +++++ .../SharedMonitorCacheLatestRegenerator.java | 94 ++ .../cache/VersionedQueryCacheEntry.java | 33 + .../monitor/search/MonitorPostFilter.java | 66 + .../search/ParallelSolrMatcherSink.java | 99 ++ .../search/QueryMatchResponseCodec.java | 192 +++ .../solr/monitor/search/QueryMatchType.java | 24 + .../monitor/search/ReverseQueryParser.java | 72 + .../search/ReverseQueryParserPlugin.java | 53 + .../search/ReverseSearchComponent.java | 188 +++ .../solr/monitor/search/SolrMatcherSink.java | 38 + .../search/SolrMatcherSinkFactory.java | 63 + .../search/SolrMonitorQueryCollector.java | 133 ++ .../monitor/search/SyncSolrMatcherSink.java | 62 + .../update/MonitorUpdateProcessorFactory.java | 56 + .../update/MonitorUpdateRequestProcessor.java | 266 ++++ .../monitor/BigDisjunctionQuery.xml | 1218 +++++++++++++++++ .../dangling-test-single-doc-batch.json | 10 + .../test-files/monitor/multi-doc-batch.json | 28 + .../test-files/monitor/single-doc-batch.json | 12 + .../solr/collection1/core.properties | 20 + .../solr/collection1/schema-stored-mq.xml | 99 ++ .../test-files/solr/collection1/schema.xml | 101 ++ .../solr/collection1/solrconfig-parallel.xml | 191 +++ .../solr/collection1/solrconfig.xml | 190 +++ .../monitor/src/test-files/solr/solr.xml | 28 + .../solr/monitor/MonitorSolrQueryTest.java | 444 ++++++ .../monitor/ParallelMonitorSolrQueryTest.java | 35 + .../monitor/StoredMonitorSolrQueryTest.java | 40 + 47 files changed, 5092 insertions(+) create mode 100644 solr/modules/monitor/build.gradle create mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/AggregatingMatcher.java create mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/CollectingMatcherProxy.java create mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/DocumentBatchVisitor.java create mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/MatcherProxy.java create mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorDataValues.java create mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java create mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/QCEVisitor.java create mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/QueryTermFilterVisitor.java create mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/SimpleMatcherProxy.java create mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/SingleMatchConsumer.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorSchemaFields.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/PresearcherFactory.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/SimpleQueryParser.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/cache/VersionedQueryCacheEntry.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/MonitorPostFilter.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchResponseCodec.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchType.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParser.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParserPlugin.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java create mode 100644 solr/modules/monitor/src/test-files/monitor/BigDisjunctionQuery.xml create mode 100644 solr/modules/monitor/src/test-files/monitor/dangling-test-single-doc-batch.json create mode 100644 solr/modules/monitor/src/test-files/monitor/multi-doc-batch.json create mode 100644 solr/modules/monitor/src/test-files/monitor/single-doc-batch.json create mode 100644 solr/modules/monitor/src/test-files/solr/collection1/core.properties create mode 100644 solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml create mode 100644 solr/modules/monitor/src/test-files/solr/collection1/schema.xml create mode 100644 solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml create mode 100644 solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml create mode 100644 solr/modules/monitor/src/test-files/solr/solr.xml create mode 100644 solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java create mode 100644 solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java create mode 100644 solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java diff --git a/settings.gradle b/settings.gradle index 69fc206de751..8174a34110bf 100644 --- a/settings.gradle +++ b/settings.gradle @@ -52,6 +52,7 @@ include "solr:modules:ltr" include "solr:modules:s3-repository" include "solr:modules:scripting" include "solr:modules:sql" +include "solr:modules:monitor" include "solr:webapp" include "solr:benchmark" include "solr:test-framework" diff --git a/solr/modules/monitor/build.gradle b/solr/modules/monitor/build.gradle new file mode 100644 index 000000000000..3d1c3642e20e --- /dev/null +++ b/solr/modules/monitor/build.gradle @@ -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. + */ + +apply plugin: 'java-library' + +description = 'Apache Solr Monitor' + +dependencies { + + implementation project(":solr:core") + implementation project(":solr:solrj") + implementation "org.apache.lucene:lucene-core" + implementation "org.apache.lucene:lucene-monitor" + implementation 'com.github.ben-manes.caffeine:caffeine' + testImplementation project(':solr:test-framework') + testImplementation 'junit:junit' +} + + diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/AggregatingMatcher.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/AggregatingMatcher.java new file mode 100644 index 000000000000..37fde6c0f78d --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/AggregatingMatcher.java @@ -0,0 +1,63 @@ +/* + * + * * 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.util.List; +import java.util.Map; +import org.apache.lucene.search.Query; + +public class AggregatingMatcher extends CandidateMatcher { + + private final CandidateMatcher collector; + + private AggregatingMatcher(List> matchers, CandidateMatcher collector) { + super(collector.searcher); + this.collector = collector; + for (var matcher : matchers) { + MultiMatchingQueries matches = matcher.finish(0, 0); + for (int doc = 0; doc < matches.getBatchSize(); doc++) { + for (T match : matches.getMatches(doc)) { + this.addMatch(match, doc); + } + } + for (Map.Entry error : matches.getErrors().entrySet()) { + this.reportError(error.getKey(), error.getValue()); + } + } + } + + @Override + protected void matchQuery(String queryId, Query matchQuery, Map metadata) { + throw new UnsupportedOperationException("only use for aggregating other matchers"); + } + + public MultiMatchingQueries finish(int queryCount) { + return finish(Long.MIN_VALUE, queryCount); + } + + @Override + public T resolve(T match1, T match2) { + return collector.resolve(match1, match2); + } + + public static AggregatingMatcher build( + List> matchers, CandidateMatcher collector) { + return new AggregatingMatcher<>(matchers, collector); + } +} diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/CollectingMatcherProxy.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/CollectingMatcherProxy.java new file mode 100644 index 000000000000..7bc5eb1c7a83 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/CollectingMatcherProxy.java @@ -0,0 +1,62 @@ +/* + * + * * 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.Map; +import org.apache.lucene.search.IndexSearcher; +import org.apache.lucene.search.Query; +import org.apache.lucene.search.ScoreMode; + +public abstract class CollectingMatcherProxy extends CollectingMatcher + implements MatcherProxy { + + private SingleMatchConsumer singleMatchConsumer; + + public CollectingMatcherProxy(IndexSearcher searcher, ScoreMode scoreMode) { + super(searcher, scoreMode); + } + + public void matchQuery(String queryId, Query matchQuery, Map metadata) { + try { + super.matchQuery(queryId, matchQuery, metadata); + } catch (Exception e) { + super.reportError(queryId, e); + } + } + + public MultiMatchingQueries finish(int queryCount) { + return super.finish(Long.MIN_VALUE, queryCount); + } + + protected void consumeMatch(String queryId, int batchDocId) throws IOException { + if (singleMatchConsumer != null) { + singleMatchConsumer.accept(queryId, batchDocId); + } + } + + public void setNextMatchConsumer(SingleMatchConsumer singleMatchConsumer) { + this.singleMatchConsumer = singleMatchConsumer; + } + + @Override + public CandidateMatcher matcher() { + return this; + } +} diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/DocumentBatchVisitor.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/DocumentBatchVisitor.java new file mode 100644 index 000000000000..84387ce501e6 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/DocumentBatchVisitor.java @@ -0,0 +1,64 @@ +/* + * + * * 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.Closeable; +import java.io.IOException; +import java.util.List; +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.LeafReader; + +public class DocumentBatchVisitor implements Closeable, 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(" ")); + } +} diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatcherProxy.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatcherProxy.java new file mode 100644 index 000000000000..592f75914331 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatcherProxy.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.lucene.monitor; + +import java.util.Map; +import org.apache.lucene.search.Query; + +public interface MatcherProxy { + + void matchQuery(String queryId, Query matchQuery, Map metadata); + + MultiMatchingQueries finish(int queryCount); + + void setNextMatchConsumer(SingleMatchConsumer singleMatchConsumer); + + CandidateMatcher matcher(); +} diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorDataValues.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorDataValues.java new file mode 100644 index 000000000000..fe568dda34ee --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorDataValues.java @@ -0,0 +1,84 @@ +/* + * + * * 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 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.search.DocIdSetIterator; + +public class MonitorDataValues { + + private SortedDocValues queryIdIt; + private SortedDocValues cacheIdIt; + private SortedDocValues mqIt; + private SortedDocValues payloadIt; + private NumericDocValues versionIt; + private int currentDoc = DocIdSetIterator.NO_MORE_DOCS; + private LeafReader reader; + + public void update(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); + payloadIt = reader.getSortedDocValues(MonitorFields.PAYLOAD); + versionIt = reader.getNumericDocValues(MonitorFields.VERSION); + currentDoc = DocIdSetIterator.NO_MORE_DOCS; + } + + public void advanceTo(int doc) { + currentDoc = doc; + } + + public String getQueryId() throws IOException { + queryIdIt.advanceExact(currentDoc); + return queryIdIt.lookupOrd(queryIdIt.ordValue()).utf8ToString(); + } + + public String getCacheId() throws IOException { + cacheIdIt.advanceExact(currentDoc); + 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 String getPayload() throws IOException { + if (payloadIt != null) { + if (payloadIt.advanceExact(currentDoc)) { + return payloadIt.lookupOrd(payloadIt.ordValue()).utf8ToString(); + } + return null; + } + return reader.document(currentDoc).get(MonitorFields.PAYLOAD); + } + + public long getVersion() throws IOException { + versionIt.advanceExact(currentDoc); + return versionIt.longValue(); + } +} diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java new file mode 100644 index 000000000000..9daa7c1bdbdb --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.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.lucene.monitor; + +import java.util.Set; + +public 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 String PAYLOAD = QueryIndex.FIELDS.mq + "_payload"; + public static final String VERSION = "_version_"; + + public static final Set RESERVED_MONITOR_FIELDS = + Set.of(QUERY_ID, CACHE_ID, MONITOR_QUERY, PAYLOAD, VERSION); +} diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/QCEVisitor.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/QCEVisitor.java new file mode 100644 index 000000000000..c09f6bef24be --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/QCEVisitor.java @@ -0,0 +1,73 @@ +/* + * + * * 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.util.ArrayList; +import java.util.List; +import java.util.Map; +import org.apache.lucene.search.Query; + +public 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 static QCEVisitor getComponent( + MonitorQuery mq, QueryDecomposer decomposer, String cacheId) { + for (QCEVisitor qce : QCEVisitor.decompose(mq, decomposer)) { + if (qce.getCacheId().equals(cacheId)) { + return qce; + } + } + throw new IllegalStateException("Corrupt monitorQuery value in index"); + } + + 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/monitor/src/java/org/apache/lucene/monitor/QueryTermFilterVisitor.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/QueryTermFilterVisitor.java new file mode 100644 index 000000000000..3c5c692dd3f1 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/QueryTermFilterVisitor.java @@ -0,0 +1,39 @@ +/* + * + * * 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.function.BiPredicate; +import org.apache.lucene.index.IndexReader; +import org.apache.lucene.util.BytesRef; + +public 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); + } +} diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/SimpleMatcherProxy.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/SimpleMatcherProxy.java new file mode 100644 index 000000000000..cdfd36a3677d --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/SimpleMatcherProxy.java @@ -0,0 +1,43 @@ +/* + * + * * 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 org.apache.lucene.search.IndexSearcher; +import org.apache.lucene.search.Scorable; +import org.apache.lucene.search.ScoreMode; + +public class SimpleMatcherProxy extends CollectingMatcherProxy { + + public SimpleMatcherProxy(IndexSearcher searcher, ScoreMode scoreMode) { + super(searcher, scoreMode); + } + + @Override + public QueryMatch resolve(QueryMatch match1, QueryMatch match2) { + return match1; + } + + @Override + protected QueryMatch doMatch(String queryId, int doc, Scorable scorer) throws IOException { + super.consumeMatch(queryId, doc); + return new QueryMatch(queryId); + } +} diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/SingleMatchConsumer.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/SingleMatchConsumer.java new file mode 100644 index 000000000000..a634cb6cbbf1 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/SingleMatchConsumer.java @@ -0,0 +1,27 @@ +/* + * + * * 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; + +public interface SingleMatchConsumer { + + void accept(String queryId, int batchDocId) throws IOException; +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java new file mode 100644 index 000000000000..9ec7c454a1ac --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java @@ -0,0 +1,35 @@ +/* + * + * * 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.monitor; + +public class MonitorConstants { + + private MonitorConstants() {} + + public static final String REVERSE_SEARCH_PARAM_NAME = "reverseSearch"; + public static final String DOCUMENT_BATCH_KEY = "documentBatch"; + public static final String SOLR_MONITOR_CACHE_NAME = "solrMonitorCache"; + public static final String MONITOR_DOCUMENTS_KEY = "monitorDocuments"; + public static final String MONITOR_DOCUMENT_KEY = "monitorDocument"; + public static final String MONITOR_QUERIES_KEY = "queries"; + public static final String MONITOR_QUERIES_RUN = "queriesRun"; + public static final String MONITOR_OUTPUT_KEY = "monitor"; + public static final String WRITE_TO_DOC_LIST_KEY = "writeToDocList"; +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorSchemaFields.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorSchemaFields.java new file mode 100644 index 000000000000..a4683a0fc880 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorSchemaFields.java @@ -0,0 +1,55 @@ +/* + * + * * 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.monitor; + +import org.apache.lucene.monitor.MonitorFields; +import org.apache.solr.schema.IndexSchema; +import org.apache.solr.schema.SchemaField; + +public class MonitorSchemaFields { + + private final SchemaField cacheId; + private final SchemaField queryId; + private final SchemaField monitorQuery; + private final SchemaField payload; + + public MonitorSchemaFields(IndexSchema indexSchema) { + this.cacheId = indexSchema.getField(MonitorFields.CACHE_ID); + this.queryId = indexSchema.getField(MonitorFields.QUERY_ID); + this.monitorQuery = indexSchema.getField(MonitorFields.MONITOR_QUERY); + this.payload = indexSchema.getField(MonitorFields.PAYLOAD); + } + + public SchemaField getCacheId() { + return cacheId; + } + + public SchemaField getQueryId() { + return queryId; + } + + public SchemaField getMonitorQuery() { + return monitorQuery; + } + + public SchemaField getPayload() { + return payload; + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/PresearcherFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/PresearcherFactory.java new file mode 100644 index 000000000000..f48cf451b597 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/PresearcherFactory.java @@ -0,0 +1,45 @@ +/* + * + * * 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.monitor; + +import org.apache.lucene.monitor.MultipassTermFilteredPresearcher; +import org.apache.lucene.monitor.Presearcher; +import org.apache.lucene.monitor.TermFilteredPresearcher; + +public class PresearcherFactory { + + public static final String TERM_FILTERED = TermFilteredPresearcher.class.getSimpleName(); + public static final String MULTI_PASS_TERM_FILTERED = + MultipassTermFilteredPresearcher.class.getSimpleName(); + + public static Presearcher build() { + return build(null); + } + + public static Presearcher build(Object type) { + if (TERM_FILTERED.equals(type)) { + return new TermFilteredPresearcher(); + } + if (MULTI_PASS_TERM_FILTERED.equals(type)) { + return new MultipassTermFilteredPresearcher(3); + } + return Presearcher.NO_FILTERING; + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/SimpleQueryParser.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/SimpleQueryParser.java new file mode 100644 index 000000000000..ca587cdc34f1 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/SimpleQueryParser.java @@ -0,0 +1,148 @@ +/* + * + * * 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.monitor; + +import java.security.Principal; +import java.util.HashMap; +import java.util.Map; +import org.apache.lucene.search.Query; +import org.apache.solr.common.SolrException; +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 SolrException(SolrException.ErrorCode.BAD_REQUEST, "could not parse query"); + } + } + + @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/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java new file mode 100644 index 000000000000..1a26f61cddec --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java @@ -0,0 +1,45 @@ +/* + * + * * 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.monitor; + +import java.io.IOException; +import java.util.Map; +import org.apache.lucene.monitor.MonitorDataValues; +import org.apache.lucene.monitor.MonitorFields; +import org.apache.lucene.monitor.MonitorQuery; +import org.apache.solr.core.SolrCore; + +public interface SolrMonitorQueryDecoder { + + MonitorQuery decode(MonitorDataValues monitorDataValues) throws IOException; + + static SolrMonitorQueryDecoder fromCore(SolrCore core) { + return monitorDataValues -> { + String id = monitorDataValues.getQueryId(); + String queryStr = monitorDataValues.getMq(); + var query = SimpleQueryParser.parse(queryStr, core); + String payload = monitorDataValues.getPayload(); + if (payload == null) { + return new MonitorQuery(id, query, queryStr, Map.of()); + } + return new MonitorQuery(id, query, queryStr, Map.of(MonitorFields.PAYLOAD, payload)); + }; + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java new file mode 100644 index 000000000000..1cb6534455dd --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.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.monitor.cache; + +import java.io.IOException; +import org.apache.lucene.monitor.MonitorDataValues; +import org.apache.lucene.monitor.QueryDecomposer; +import org.apache.lucene.util.BytesRef; +import org.apache.solr.monitor.SolrMonitorQueryDecoder; + +public interface MonitorQueryCache { + + VersionedQueryCacheEntry computeIfStale( + MonitorDataValues dataValues, SolrMonitorQueryDecoder decoder) throws IOException; + + boolean acceptTerm(String field, BytesRef value); + + QueryDecomposer getDecomposer(); +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java new file mode 100644 index 000000000000..918856e4a1db --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java @@ -0,0 +1,316 @@ +/* + * + * * 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.monitor.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.MonitorDataValues; +import org.apache.lucene.monitor.MonitorQuery; +import org.apache.lucene.monitor.QCEVisitor; +import org.apache.lucene.monitor.QueryDecomposer; +import org.apache.lucene.monitor.QueryTermFilterVisitor; +import org.apache.lucene.util.BytesRef; +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.monitor.SolrMonitorQueryDecoder; +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 SharedMonitorCache extends SolrCacheBase + implements SolrCache, + MonitorQueryCache, + RemovalListener { + + private static final long START_HIGH_WATER_MARK = -1; + + private final QueryDecomposer queryDecomposer = new QueryDecomposer(); + 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; + + @Override + public VersionedQueryCacheEntry computeIfStale( + MonitorDataValues dataValues, SolrMonitorQueryDecoder decoder) throws IOException { + return mqCacheMap() + .compute( + dataValues.getCacheId(), + (cacheId, prevEntry) -> compute(cacheId, prevEntry, dataValues, decoder::decode)); + } + + @Override + public boolean acceptTerm(String field, BytesRef value) { + return termAcceptor.test(field, value); + } + + @Override + public QueryDecomposer getDecomposer() { + return queryDecomposer; + } + + private Map mqCacheMap() { + return mqCache.asMap(); + } + + @Override + public Object init(Map args, Object persistence, CacheRegenerator regenerator) { + super.init(args, regenerator); + String str = args.get(SIZE_PARAM); + int maxSize = (str == null) ? 100_000 : 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(maxSize, maxIdleTimeSec); + return persistence; + } + + private Cache buildCache(int maxSize, int maxIdleTimeSec) { + Caffeine builder = + Caffeine.newBuilder().initialCapacity(initialSize).removalListener(this).recordStats(); + if (maxIdleTimeSec > 0) { + builder.expireAfterAccess(Duration.ofSeconds(maxIdleTimeSec)); + } + 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"); + } + }); + } + + @Override + public void clear() { + mqCacheMap().clear(); + } + + @Override + public void warm(SolrIndexSearcher searcher, SolrCache old) { + try { + SharedMonitorCache oldSharedMonitorCache = + old instanceof SharedMonitorCache ? (SharedMonitorCache) old : null; + if (oldSharedMonitorCache != null) { + mqCache = oldSharedMonitorCache.mqCache; + versionHighWaterMark = oldSharedMonitorCache.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 (oldSharedMonitorCache != null) { + var oldStats = oldSharedMonitorCache.currentStats.get(); + priorHits = oldSharedMonitorCache.priorHits + oldStats.hits; + priorLookups = oldSharedMonitorCache.priorLookups + oldStats.lookups; + cumulativeGenerationTimeMs = + generationTimeMs + oldSharedMonitorCache.cumulativeGenerationTimeMs; + cumulativeDocVisits = oldSharedMonitorCache.cumulativeDocVisits + docVisits; + } + } catch (IOException e) { + throw new SolrException(SolrException.ErrorCode.INVALID_STATE, "could not boostrap cache"); + } + } + + @Override + public int getMaxSize() { + return Integer.MAX_VALUE; + } + + @Override + public void setMaxSize(int maxSize) { + throw new UnsupportedOperationException("maxSize is unsupported"); + } + + @Override + public int getMaxRamMB() { + return -1; + } + + @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("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, + MonitorDataValues dataValues, + IOFunction decoder) { + try { + var version = dataValues.getVersion(); + if (prevEntry == null || version > prevEntry.version) { + var monitorQuery = decoder.apply(dataValues); + QCEVisitor component = QCEVisitor.getComponent(monitorQuery, getDecomposer(), 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 MonitorQueryCache", 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/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java new file mode 100644 index 000000000000..43721217b6fc --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java @@ -0,0 +1,94 @@ +/* + * + * * 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.monitor.cache; + +import java.io.IOException; +import org.apache.lucene.document.LongPoint; +import org.apache.lucene.index.LeafReaderContext; +import org.apache.lucene.monitor.MonitorDataValues; +import org.apache.lucene.monitor.MonitorFields; +import org.apache.lucene.search.IndexSearcher; +import org.apache.solr.monitor.SolrMonitorQueryDecoder; +import org.apache.solr.search.CacheRegenerator; +import org.apache.solr.search.SolrCache; +import org.apache.solr.search.SolrIndexSearcher; + +public class SharedMonitorCacheLatestRegenerator 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 SharedMonitorCache)) { + throw new IllegalArgumentException( + this.getClass().getSimpleName() + + " only supports " + + SharedMonitorCache.class.getSimpleName()); + } + var cache = (SharedMonitorCache) newCache; + var reader = searcher.getIndexReader(); + int batchSize = Math.min(MAX_BATCH_SIZE, cache.getInitialSize()); + var topDocs = + new IndexSearcher(searcher.getTopReaderContext()) + .search( + LongPoint.newRangeQuery( + MonitorFields.VERSION, cache.versionHighWaterMark, Long.MAX_VALUE), + batchSize) + .scoreDocs; + int batchesRemaining = cache.getInitialSize() / batchSize; + while (topDocs.length > 0 && batchesRemaining > 0) { + int docIndex = 0; + SolrMonitorQueryDecoder decoder = SolrMonitorQueryDecoder.fromCore(searcher.getCore()); + for (LeafReaderContext ctx : reader.leaves()) { + MonitorDataValues dataValues = new MonitorDataValues(); + dataValues.update(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++; + 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, + LongPoint.newRangeQuery( + MonitorFields.VERSION, cache.versionHighWaterMark, Long.MAX_VALUE), + batchSize) + .scoreDocs; + batchesRemaining--; + } + return false; + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/VersionedQueryCacheEntry.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/VersionedQueryCacheEntry.java new file mode 100644 index 000000000000..df74ed208069 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/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.monitor.cache; + +import org.apache.lucene.monitor.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/monitor/src/java/org/apache/solr/monitor/search/MonitorPostFilter.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/MonitorPostFilter.java new file mode 100644 index 000000000000..d0bbf0a0eff7 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/MonitorPostFilter.java @@ -0,0 +1,66 @@ +/* + * + * * 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.monitor.search; + +import org.apache.lucene.search.IndexSearcher; +import org.apache.lucene.search.QueryVisitor; +import org.apache.solr.search.DelegatingCollector; +import org.apache.solr.search.ExtendedQueryBase; +import org.apache.solr.search.PostFilter; + +class MonitorPostFilter extends ExtendedQueryBase implements PostFilter { + + private final SolrMonitorQueryCollector.CollectorContext collectorContext; + + MonitorPostFilter(SolrMonitorQueryCollector.CollectorContext collectorContext) { + this.collectorContext = collectorContext; + } + + @Override + public void visit(QueryVisitor visitor) { + visitor.visitLeaf(this); + } + + @Override + public DelegatingCollector getFilterCollector(IndexSearcher searcher) { + return new SolrMonitorQueryCollector(collectorContext); + } + + @Override + public boolean getCache() { + return false; + } + + @Override + public int getCost() { + // cost has to be >= 100 since we only support post filtering + return Math.max(super.getCost(), 111); + } + + @Override + public boolean equals(Object o) { + return this == o; + } + + @Override + public int hashCode() { + return System.identityHashCode(this); + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java new file mode 100644 index 000000000000..c9ae48ffa836 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java @@ -0,0 +1,99 @@ +/* + * + * * 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.monitor.search; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.concurrent.CompletionService; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorCompletionService; +import java.util.concurrent.ExecutorService; +import java.util.function.Consumer; +import java.util.function.Function; +import org.apache.lucene.monitor.AggregatingMatcher; +import org.apache.lucene.monitor.CandidateMatcher; +import org.apache.lucene.monitor.MatcherProxy; +import org.apache.lucene.monitor.MultiMatchingQueries; +import org.apache.lucene.monitor.QueryMatch; +import org.apache.lucene.monitor.SingleMatchConsumer; +import org.apache.lucene.search.IndexSearcher; +import org.apache.lucene.search.Query; + +class ParallelSolrMatcherSink implements SolrMatcherSink { + + private final CompletionService> completionService; + private final Function> matcherProxyFactory; + private final IndexSearcher docBatchSearcher; + private final Consumer> queriesConsumer; + private int tasksLeft; + + public ParallelSolrMatcherSink( + ExecutorService executor, + Function> matcherProxyFactory, + IndexSearcher docBatchSearcher, + Consumer> queriesConsumer) { + this.completionService = new ExecutorCompletionService<>(executor); + this.matcherProxyFactory = matcherProxyFactory; + this.docBatchSearcher = docBatchSearcher; + this.queriesConsumer = queriesConsumer; + } + + @Override + public void matchQuery( + String queryId, + Query matchQuery, + Map metadata, + SingleMatchConsumer matchConsumer) { + completionService.submit( + () -> { + var matcherProxy = matcherProxyFactory.apply(docBatchSearcher); + matcherProxy.matchQuery(queryId, matchQuery, metadata); + return matcherProxy.matcher(); + }); + tasksLeft++; + } + + @Override + public void complete() throws IOException { + List> matchers = new ArrayList<>(); + int queryCount = tasksLeft; + while (tasksLeft-- > 0) { + try { + matchers.add(completionService.take().get()); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + throw new IOException(e); + } catch (ExecutionException e) { + throw new IllegalStateException( + MatcherProxy.class.getSimpleName() + " should never throw an exception", e); + } + } + var aggregatingMatcher = + AggregatingMatcher.build(matchers, matcherProxyFactory.apply(docBatchSearcher).matcher()); + queriesConsumer.accept(aggregatingMatcher.finish(queryCount)); + } + + @Override + public boolean isParallel() { + return true; + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchResponseCodec.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchResponseCodec.java new file mode 100644 index 000000000000..47537591c1c1 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchResponseCodec.java @@ -0,0 +1,192 @@ +/* + * + * * 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.monitor.search; + +import static org.apache.solr.monitor.MonitorConstants.MONITOR_DOCUMENTS_KEY; +import static org.apache.solr.monitor.MonitorConstants.MONITOR_DOCUMENT_KEY; +import static org.apache.solr.monitor.MonitorConstants.MONITOR_OUTPUT_KEY; +import static org.apache.solr.monitor.MonitorConstants.MONITOR_QUERIES_KEY; +import static org.apache.solr.monitor.MonitorConstants.MONITOR_QUERIES_RUN; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.Stream; +import org.apache.lucene.monitor.MultiMatchingQueries; +import org.apache.lucene.monitor.QueryMatch; +import org.apache.lucene.util.BytesRef; +import org.apache.solr.common.SolrException; +import org.apache.solr.common.util.NamedList; + +class QueryMatchResponseCodec { + + @SuppressWarnings({"unchecked"}) + static Map mergeResponses( + List> responses, QueryMatchType type) { + Map> wrappedMerged = new HashMap<>(); + int queriesRun = 0; + for (var response : responses) { + Object smq = response.get(MONITOR_OUTPUT_KEY); + if (!(smq instanceof Map)) { + throw new SolrException( + SolrException.ErrorCode.BAD_REQUEST, MONITOR_OUTPUT_KEY + " must be a map"); + } + Map singleMonitorOutput = (Map) smq; + decodeToWrappers(singleMonitorOutput, wrappedMerged, type); + var delta = singleMonitorOutput.get(MONITOR_QUERIES_RUN); + if (!(delta instanceof Integer)) { + throw new SolrException( + SolrException.ErrorCode.BAD_REQUEST, MONITOR_QUERIES_RUN + " must be an integer"); + } + queriesRun += (Integer) delta; + } + + for (var mergedValues : wrappedMerged.values()) { + Collections.sort(mergedValues); + } + Map finalDocOutputs = + wrappedMerged.entrySet().stream() + .collect( + Collectors.toMap( + Map.Entry::getKey, + entry -> encodeWrappers(entry.getValue().stream(), entry.getKey()))); + Map output = new HashMap<>(); + output.put(MONITOR_DOCUMENTS_KEY, finalDocOutputs); + output.put(MONITOR_QUERIES_RUN, queriesRun); + return output; + } + + @SuppressWarnings({"unchecked"}) + private static void decodeToWrappers( + Object object, Map> output, QueryMatchType type) { + if (!(object instanceof Map)) { + throw new IllegalArgumentException("input object should be a map"); + } + Map docLevelMQResponse = (Map) object; + Object monitorDocumentsRaw = docLevelMQResponse.get(MONITOR_DOCUMENTS_KEY); + if (!(monitorDocumentsRaw instanceof Map)) { + throw new IllegalArgumentException(MONITOR_DOCUMENTS_KEY + " should be a map"); + } + var monitorDocuments = (Map) monitorDocumentsRaw; + if (type == QueryMatchType.SIMPLE) { + for (var docEntryRaw : monitorDocuments.values()) { + if (!(docEntryRaw instanceof Map)) { + throw new IllegalArgumentException(MONITOR_DOCUMENTS_KEY + " should contain maps"); + } + var docEntry = (Map) docEntryRaw; + Object docRaw = docEntry.get(MONITOR_DOCUMENT_KEY); + if (!(docRaw instanceof Integer)) { + throw new IllegalStateException(MONITOR_DOCUMENT_KEY + " needs to be an int"); + } + Object monitorQueriesRaw = docEntry.get(MONITOR_QUERIES_KEY); + if (!(monitorQueriesRaw instanceof List)) { + throw new IllegalStateException(MONITOR_QUERIES_KEY + " needs to be an list"); + } + int doc = (Integer) docRaw; + List wrappers = output.computeIfAbsent(doc, i -> new ArrayList<>()); + List serializableFormMQs = (List) monitorQueriesRaw; + for (var serializableForm : serializableFormMQs) { + wrappers.add(SimpleQueryMatchWrapper.fromSerializableForm(serializableForm)); + } + } + } + } + + static void simpleEncode( + MultiMatchingQueries matchingQueries, + Map output, + int docBatchSize) { + encodeMultiMatchingQuery( + matchingQueries, output, docBatchSize, SimpleQueryMatchWrapper::fromQueryMatch); + } + + private static void encodeMultiMatchingQuery( + MultiMatchingQueries matchingQueries, + Map output, + int docBatchSize, + Function wrappingFunction) { + if (matchingQueries.getBatchSize() != docBatchSize) { + throw new IllegalArgumentException("output size doesn't match document batch size"); + } + Map docOutputs = + IntStream.range(0, matchingQueries.getBatchSize()) + .mapToObj( + doc -> + encodeWrappers( + matchingQueries.getMatches(doc).stream().map(wrappingFunction), doc)) + .collect( + Collectors.toMap( + wrapper -> (Integer) wrapper.get(MONITOR_DOCUMENT_KEY), Function.identity())); + output.put(MONITOR_DOCUMENTS_KEY, docOutputs); + output.put(MONITOR_QUERIES_RUN, matchingQueries.getQueriesRun()); + } + + private static Map encodeWrappers(Stream matches, int doc) { + return Map.of( + MONITOR_DOCUMENT_KEY, + doc, + MONITOR_QUERIES_KEY, + matches.sorted().map(QueryMatchWrapper::toSerializableForm).collect(Collectors.toList())); + } + + private interface QueryMatchWrapper extends Comparable { + + Object toSerializableForm(); + } + + private static class SimpleQueryMatchWrapper implements QueryMatchWrapper { + + private final BytesRef queryId; + + private SimpleQueryMatchWrapper(BytesRef queryId) { + this.queryId = queryId; + } + + @Override + public int compareTo(QueryMatchWrapper o) { + if (!(o instanceof SimpleQueryMatchWrapper)) { + throw new IllegalArgumentException( + "SimpleQueryMatchWrapper can only be compared to other SimpleQueryMatchWrappers"); + } + return queryId.compareTo(((SimpleQueryMatchWrapper) o).queryId); + } + + private static SimpleQueryMatchWrapper fromQueryMatch(QueryMatch queryMatch) { + return new SimpleQueryMatchWrapper(new BytesRef(queryMatch.getQueryId())); + } + + private static SimpleQueryMatchWrapper fromSerializableForm(Object serializableForm) { + if (!(serializableForm instanceof String)) { + throw new IllegalArgumentException("only support decoding for String"); + } + return new SimpleQueryMatchWrapper(new BytesRef((String) serializableForm)); + } + + @Override + public Object toSerializableForm() { + return queryId.utf8ToString(); + } + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchType.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchType.java new file mode 100644 index 000000000000..2b28d6c26f84 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchType.java @@ -0,0 +1,24 @@ +/* + * + * * 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.monitor.search; + +public enum QueryMatchType { + SIMPLE +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParser.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParser.java new file mode 100644 index 000000000000..2cb4df1a103e --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParser.java @@ -0,0 +1,72 @@ +/* + * + * * 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.monitor.search; + +import static org.apache.solr.monitor.MonitorConstants.DOCUMENT_BATCH_KEY; +import static org.apache.solr.monitor.MonitorConstants.SOLR_MONITOR_CACHE_NAME; + +import java.util.function.BiPredicate; +import org.apache.lucene.index.LeafReader; +import org.apache.lucene.monitor.DocumentBatchVisitor; +import org.apache.lucene.monitor.Presearcher; +import org.apache.lucene.search.Query; +import org.apache.lucene.util.BytesRef; +import org.apache.solr.common.params.SolrParams; +import org.apache.solr.monitor.cache.MonitorQueryCache; +import org.apache.solr.request.SolrQueryRequest; +import org.apache.solr.search.QParser; +import org.apache.solr.search.SyntaxError; + +public class ReverseQueryParser extends QParser { + + private static final BiPredicate ALL_TERM_ACCEPTOR = (__, ___) -> true; + + private final Presearcher presearcher; + + public ReverseQueryParser( + String qstr, + SolrParams localParams, + SolrParams params, + SolrQueryRequest req, + Presearcher presearcher) { + super(qstr, localParams, params, req); + this.presearcher = presearcher; + } + + @Override + public Query parse() throws SyntaxError { + var obj = req.getContext().get(DOCUMENT_BATCH_KEY); + if (!(obj instanceof DocumentBatchVisitor)) { + throw new SyntaxError("Document Batch is of unexpected type"); + } + var documentBatch = (DocumentBatchVisitor) obj; + LeafReader queryIndexReader = documentBatch.get(); + return presearcher.buildQuery(queryIndexReader, getTermAcceptor()); + } + + private BiPredicate getTermAcceptor() { + var searcher = req.getSearcher(); + MonitorQueryCache cache = (MonitorQueryCache) searcher.getCache(SOLR_MONITOR_CACHE_NAME); + if (cache == null) { + return ALL_TERM_ACCEPTOR; + } + return cache::acceptTerm; + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParserPlugin.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParserPlugin.java new file mode 100644 index 000000000000..ba623bab8dc3 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParserPlugin.java @@ -0,0 +1,53 @@ +/* + * + * * 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.monitor.search; + +import java.io.IOException; +import org.apache.lucene.monitor.Presearcher; +import org.apache.solr.common.params.SolrParams; +import org.apache.solr.common.util.NamedList; +import org.apache.solr.monitor.PresearcherFactory; +import org.apache.solr.request.SolrQueryRequest; +import org.apache.solr.search.QParser; +import org.apache.solr.search.QParserPlugin; + +public class ReverseQueryParserPlugin extends QParserPlugin { + + public static final String NAME = "reverse"; + + // TODO parameterize this + private Presearcher presearcher = PresearcherFactory.build(PresearcherFactory.TERM_FILTERED); + + @Override + public QParser createParser( + String qstr, SolrParams localParams, SolrParams params, SolrQueryRequest req) { + return new ReverseQueryParser(qstr, localParams, params, req, presearcher); + } + + @Override + public void close() throws IOException { + super.close(); + } + + @Override + public void init(NamedList args) { + super.init(args); + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java new file mode 100644 index 000000000000..b7644167716f --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -0,0 +1,188 @@ +/* + * + * * 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.monitor.search; + +import static org.apache.solr.monitor.MonitorConstants.DOCUMENT_BATCH_KEY; +import static org.apache.solr.monitor.MonitorConstants.MONITOR_DOCUMENTS_KEY; +import static org.apache.solr.monitor.MonitorConstants.MONITOR_OUTPUT_KEY; +import static org.apache.solr.monitor.MonitorConstants.REVERSE_SEARCH_PARAM_NAME; +import static org.apache.solr.monitor.MonitorConstants.SOLR_MONITOR_CACHE_NAME; +import static org.apache.solr.monitor.MonitorConstants.WRITE_TO_DOC_LIST_KEY; +import static org.apache.solr.monitor.search.QueryMatchResponseCodec.mergeResponses; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ExecutorService; +import java.util.stream.Collectors; +import org.apache.lucene.document.Document; +import org.apache.lucene.monitor.DocumentBatchVisitor; +import org.apache.lucene.search.Query; +import org.apache.lucene.util.NamedThreadFactory; +import org.apache.solr.common.SolrException; +import org.apache.solr.common.SolrException.ErrorCode; +import org.apache.solr.common.util.ExecutorUtil; +import org.apache.solr.common.util.NamedList; +import org.apache.solr.core.CloseHook; +import org.apache.solr.core.SolrCore; +import org.apache.solr.handler.component.ResponseBuilder; +import org.apache.solr.handler.component.SearchComponent; +import org.apache.solr.handler.component.ShardRequest; +import org.apache.solr.handler.loader.JsonLoader; +import org.apache.solr.monitor.SolrMonitorQueryDecoder; +import org.apache.solr.monitor.cache.MonitorQueryCache; +import org.apache.solr.monitor.cache.SharedMonitorCache; +import org.apache.solr.request.SolrQueryRequest; +import org.apache.solr.search.QParser; +import org.apache.solr.search.SyntaxError; +import org.apache.solr.update.DocumentBuilder; +import org.apache.solr.util.plugin.SolrCoreAware; + +public class ReverseSearchComponent extends SearchComponent implements SolrCoreAware { + + private static final String MATCHER_THREAD_COUNT_KEY = "threadCount"; + + private SolrMatcherSinkFactory solrMatcherSinkFactory = new SolrMatcherSinkFactory(); + + private ExecutorService executor; + + @Override + public void init(NamedList args) { + super.init(args); + Object threadCount = args.get(MATCHER_THREAD_COUNT_KEY); + if (threadCount instanceof Integer) { + executor = + ExecutorUtil.newMDCAwareFixedThreadPool( + (Integer) threadCount, new NamedThreadFactory("monitor-matcher")); + solrMatcherSinkFactory = new SolrMatcherSinkFactory(executor); + } + } + + @Override + public void prepare(ResponseBuilder rb) { + if (skipReverseSearch(rb)) { + return; + } + var req = rb.req; + var documentBatch = documentBatch(req); + req.getContext().put(DOCUMENT_BATCH_KEY, documentBatch); + var writeToDocListRaw = req.getParams().get(WRITE_TO_DOC_LIST_KEY, "false"); + boolean writeToDocList = Boolean.parseBoolean(writeToDocListRaw); + List mutableFilters = + Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); + Map monitorResult = new HashMap<>(); + var simpleMatcherSink = solrMatcherSinkFactory.buildSimple(documentBatch, monitorResult); + if (simpleMatcherSink.isParallel() && writeToDocList) { + throw new SolrException( + ErrorCode.BAD_REQUEST, + "writeToDocList is not supported for parallel matcher. Consider adding more shards/cores instead of parallel matcher."); + } + try { + Query preFilterQuery = + QParser.getParser("{!" + ReverseQueryParserPlugin.NAME + "}", req).parse(); + rb.setQuery(preFilterQuery); + var searcher = req.getSearcher(); + MonitorQueryCache solrMonitorCache = + (SharedMonitorCache) searcher.getCache(SOLR_MONITOR_CACHE_NAME); + SolrMonitorQueryDecoder queryDecoder = SolrMonitorQueryDecoder.fromCore(req.getCore()); + mutableFilters.add( + new MonitorPostFilter( + new SolrMonitorQueryCollector.CollectorContext( + solrMonitorCache, queryDecoder, simpleMatcherSink, writeToDocList))); + rb.setFilters(mutableFilters); + rb.rsp.add(MONITOR_OUTPUT_KEY, monitorResult); + } catch (SyntaxError e) { + throw new SolrException( + SolrException.ErrorCode.BAD_REQUEST, "Syntax error in query: " + e.getMessage()); + } + } + + @SuppressWarnings({"unchecked"}) + private DocumentBatchVisitor documentBatch(SolrQueryRequest req) { + Object jsonParams = req.getJSON().get("params"); + if (!(jsonParams instanceof Map)) { + throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "need params"); + } + var paramMap = (Map) jsonParams; + var documents = paramMap.get(MONITOR_DOCUMENTS_KEY); + if (!(documents instanceof List)) { + throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "need documents list"); + } + List luceneDocs = new ArrayList<>(); + for (var 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"); + } + var solrInputDoc = JsonLoader.buildDoc((Map) document); + var luceneDoc = DocumentBuilder.toDocument(solrInputDoc, req.getSchema()); + luceneDocs.add(luceneDoc); + } + return DocumentBatchVisitor.of(req.getSchema().getIndexAnalyzer(), luceneDocs); + } + + @Override + public void process(ResponseBuilder rb) throws IOException { + /* no-op */ + } + + @Override + public void handleResponses(ResponseBuilder rb, ShardRequest sreq) { + if (skipReverseSearch(rb) || (sreq.purpose & ShardRequest.PURPOSE_GET_TOP_IDS) == 0) { + return; + } + var responses = + sreq.responses.stream() + .map(shardResponse -> shardResponse.getSolrResponse().getResponse()) + .collect(Collectors.toList()); + rb.rsp.getValues().removeAll(MONITOR_OUTPUT_KEY); + var finalOutput = mergeResponses(responses, QueryMatchType.SIMPLE); + rb.rsp.add(MONITOR_OUTPUT_KEY, finalOutput); + } + + @Override + public void finishStage(ResponseBuilder rb) { + super.finishStage(rb); + } + + @Override + public String getDescription() { + return "Component that integrates with lucene monitor for reverse search."; + } + + private static boolean skipReverseSearch(ResponseBuilder rb) { + return !rb.req.getParams().getBool(REVERSE_SEARCH_PARAM_NAME, false); + } + + @Override + public void inform(SolrCore core) { + core.addCloseHook( + new CloseHook() { + @Override + public void preClose(SolrCore core) { + ExecutorUtil.shutdownAndAwaitTermination(executor); + } + }); + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java new file mode 100644 index 000000000000..c3dc5f72e038 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java @@ -0,0 +1,38 @@ +/* + * + * * 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.monitor.search; + +import java.io.IOException; +import java.util.Map; +import org.apache.lucene.monitor.SingleMatchConsumer; +import org.apache.lucene.search.Query; + +interface SolrMatcherSink { + + void matchQuery( + String queryId, + Query matchQuery, + Map metadata, + SingleMatchConsumer singleMatchConsumer); + + void complete() throws IOException; + + boolean isParallel(); +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java new file mode 100644 index 000000000000..a1fdaf25d666 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java @@ -0,0 +1,63 @@ +/* + * + * * 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.monitor.search; + +import java.util.Map; +import java.util.concurrent.ExecutorService; +import java.util.function.Consumer; +import org.apache.lucene.monitor.DocumentBatchVisitor; +import org.apache.lucene.monitor.MatcherProxy; +import org.apache.lucene.monitor.MultiMatchingQueries; +import org.apache.lucene.monitor.QueryMatch; +import org.apache.lucene.monitor.SimpleMatcherProxy; +import org.apache.lucene.search.IndexSearcher; +import org.apache.lucene.search.ScoreMode; + +class SolrMatcherSinkFactory { + + private final ExecutorService executorService; + + SolrMatcherSinkFactory() { + this(null); + } + + SolrMatcherSinkFactory(ExecutorService executorService) { + this.executorService = executorService; + } + + SolrMatcherSink buildSimple( + DocumentBatchVisitor documentBatch, Map monitorResult) { + Consumer> simpleEncoder = + matchingQueries -> + QueryMatchResponseCodec.simpleEncode( + matchingQueries, monitorResult, documentBatch.size()); + var docBatchSearcher = new IndexSearcher(documentBatch.get()); + if (executorService == null) { + return new SyncSolrMatcherSink<>(buildSimpleMatcherProxy(docBatchSearcher), simpleEncoder); + } else { + return new ParallelSolrMatcherSink<>( + executorService, this::buildSimpleMatcherProxy, docBatchSearcher, simpleEncoder); + } + } + + private MatcherProxy buildSimpleMatcherProxy(IndexSearcher docBatchSearcher) { + return new SimpleMatcherProxy(docBatchSearcher, ScoreMode.COMPLETE_NO_SCORES); + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java new file mode 100644 index 000000000000..ce216ec85506 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java @@ -0,0 +1,133 @@ +/* + * + * * 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.monitor.search; + +import java.io.IOException; +import java.util.function.Function; +import org.apache.lucene.index.LeafReaderContext; +import org.apache.lucene.monitor.MonitorDataValues; +import org.apache.lucene.monitor.QCEVisitor; +import org.apache.lucene.monitor.SingleMatchConsumer; +import org.apache.lucene.search.ScoreMode; +import org.apache.solr.monitor.SolrMonitorQueryDecoder; +import org.apache.solr.monitor.cache.MonitorQueryCache; +import org.apache.solr.monitor.cache.VersionedQueryCacheEntry; +import org.apache.solr.search.DelegatingCollector; + +class SolrMonitorQueryCollector extends DelegatingCollector { + + private final MonitorQueryCache monitorQueryCache; + private final SolrMonitorQueryDecoder queryDecoder; + private final SolrMatcherSink matcherSink; + private final MonitorDataValues dataValues = new MonitorDataValues(); + private final Function docIdForwarder; + + SolrMonitorQueryCollector(CollectorContext collectorContext) { + this.monitorQueryCache = collectorContext.queryCache; + this.queryDecoder = collectorContext.queryDecoder; + this.matcherSink = collectorContext.solrMatcherSink; + if (collectorContext.writeToDocList) { + this.docIdForwarder = MatchingDocForwarder::new; + } else { + this.docIdForwarder = __ -> null; + } + } + + @Override + public void collect(int doc) throws IOException { + dataValues.advanceTo(doc); + var versionedEntry = monitorQueryCache.computeIfStale(dataValues, queryDecoder); + var entry = getEntry(versionedEntry, dataValues); + var queryId = dataValues.getQueryId(); + var forwarder = docIdForwarder.apply(doc); + matcherSink.matchQuery(queryId, entry.getMatchQuery(), entry.getMetadata(), forwarder); + } + + private QCEVisitor getEntry(VersionedQueryCacheEntry versionedEntry, MonitorDataValues dataValues) + throws IOException { + if (versionedEntry.version != dataValues.getVersion()) { + // The cache is more up-to-date than the index associated with this collector. + // For consistency, we parse the query from the earlier index state. + return QCEVisitor.getComponent( + queryDecoder.decode(dataValues), + monitorQueryCache.getDecomposer(), + dataValues.getCacheId()); + } + return versionedEntry.entry; + } + + private void superCollect(int doc) throws IOException { + super.collect(doc); + } + + @Override + public void doSetNextReader(LeafReaderContext context) throws IOException { + super.doSetNextReader(context); + dataValues.update(context); + } + + @Override + public ScoreMode scoreMode() { + return ScoreMode.COMPLETE_NO_SCORES; + } + + @Override + public void complete() throws IOException { + super.complete(); + matcherSink.complete(); + } + + static class CollectorContext { + + private final MonitorQueryCache queryCache; + private final SolrMonitorQueryDecoder queryDecoder; + private final SolrMatcherSink solrMatcherSink; + private final boolean writeToDocList; + + CollectorContext( + MonitorQueryCache queryCache, + SolrMonitorQueryDecoder queryDecoder, + SolrMatcherSink solrMatcherSink, + boolean writeToDocList) { + this.queryCache = queryCache; + this.queryDecoder = queryDecoder; + this.solrMatcherSink = solrMatcherSink; + this.writeToDocList = writeToDocList; + } + } + + private class MatchingDocForwarder implements SingleMatchConsumer { + + private final int doc; + private boolean visited; + + private MatchingDocForwarder(int doc) { + this.doc = doc; + } + + @Override + public void accept(String __, int ___) throws IOException { + if (!visited) { + superCollect(doc); + } + visited = true; + } + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java new file mode 100644 index 000000000000..1b9b14a8a28a --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java @@ -0,0 +1,62 @@ +/* + * + * * 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.monitor.search; + +import java.util.Map; +import java.util.function.Consumer; +import org.apache.lucene.monitor.MatcherProxy; +import org.apache.lucene.monitor.MultiMatchingQueries; +import org.apache.lucene.monitor.QueryMatch; +import org.apache.lucene.monitor.SingleMatchConsumer; +import org.apache.lucene.search.Query; + +class SyncSolrMatcherSink implements SolrMatcherSink { + + private final MatcherProxy matcherProxy; + private final Consumer> queriesConsumer; + private int queryCount; + + SyncSolrMatcherSink( + MatcherProxy matcherProxy, Consumer> queriesConsumer) { + this.matcherProxy = matcherProxy; + this.queriesConsumer = queriesConsumer; + } + + @Override + public void matchQuery( + String queryId, + Query matchQuery, + Map metadata, + SingleMatchConsumer singleMatchConsumer) { + queryCount++; + matcherProxy.setNextMatchConsumer(singleMatchConsumer); + matcherProxy.matchQuery(queryId, matchQuery, metadata); + } + + @Override + public void complete() { + queriesConsumer.accept(matcherProxy.finish(queryCount)); + } + + @Override + public boolean isParallel() { + return false; + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java new file mode 100644 index 000000000000..321f7a43887f --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java @@ -0,0 +1,56 @@ +/* + * + * * 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.monitor.update; + +import org.apache.lucene.monitor.MonitorFields; +import org.apache.lucene.monitor.Presearcher; +import org.apache.solr.common.util.NamedList; +import org.apache.solr.monitor.PresearcherFactory; +import org.apache.solr.request.SolrQueryRequest; +import org.apache.solr.response.SolrQueryResponse; +import org.apache.solr.update.processor.UpdateRequestProcessor; +import org.apache.solr.update.processor.UpdateRequestProcessorFactory; + +public class MonitorUpdateProcessorFactory extends UpdateRequestProcessorFactory { + + private Presearcher presearcher = PresearcherFactory.build(); + private String queryFieldNameOverride; + private String payloadFieldNameOverride; + + @Override + public UpdateRequestProcessor getInstance( + SolrQueryRequest req, SolrQueryResponse rsp, UpdateRequestProcessor next) { + String queryFieldName = + queryFieldNameOverride == null ? MonitorFields.MONITOR_QUERY : queryFieldNameOverride; + String payloadFieldName = + payloadFieldNameOverride == null ? MonitorFields.PAYLOAD : payloadFieldNameOverride; + return new MonitorUpdateRequestProcessor( + next, queryFieldName, req.getCore(), presearcher, payloadFieldName); + } + + @Override + public void init(NamedList args) { + super.init(args); + Object presearcherType = args.get("presearcherType"); + presearcher = PresearcherFactory.build(presearcherType); + queryFieldNameOverride = (String) args.get("queryFieldName"); + payloadFieldNameOverride = (String) args.get("payloadFieldName"); + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java new file mode 100644 index 000000000000..8cbadd0316b9 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java @@ -0,0 +1,266 @@ +/* + * + * * 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.monitor.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.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.MonitorFields; +import org.apache.lucene.monitor.MonitorQuery; +import org.apache.lucene.monitor.Presearcher; +import org.apache.lucene.monitor.QCEVisitor; +import org.apache.lucene.monitor.QueryDecomposer; +import org.apache.lucene.util.BytesRef; +import org.apache.solr.common.SolrException; +import org.apache.solr.common.SolrInputDocument; +import org.apache.solr.common.util.JavaBinCodec; +import org.apache.solr.core.SolrCore; +import org.apache.solr.monitor.MonitorSchemaFields; +import org.apache.solr.monitor.SimpleQueryParser; +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; + +public class MonitorUpdateRequestProcessor extends UpdateRequestProcessor { + + private final String queryFieldName; + private final String payloadFieldName; + private final SolrCore core; + private final IndexSchema indexSchema; + private final Presearcher presearcher; + private final MonitorSchemaFields monitorSchemaFields; + private final QueryDecomposer decomposer = new QueryDecomposer(); + + public MonitorUpdateRequestProcessor( + UpdateRequestProcessor next, + String queryFieldName, + SolrCore core, + Presearcher presearcher, + String payloadFieldName) { + super(next); + this.queryFieldName = queryFieldName; + this.payloadFieldName = payloadFieldName; + this.core = core; + this.indexSchema = core.getLatestSchema(); + this.presearcher = presearcher; + this.monitorSchemaFields = new MonitorSchemaFields(indexSchema); + } + + @Override + public void processAdd(AddUpdateCommand cmd) throws IOException { + var solrInputDocument = cmd.getSolrInputDocument(); + var queryId = + (String) solrInputDocument.getFieldValue(indexSchema.getUniqueKeyField().getName()); + var queryFieldValue = solrInputDocument.getFieldValue(queryFieldName); + if (queryFieldValue != null) { + var payload = + Optional.ofNullable(solrInputDocument.getFieldValue(payloadFieldName)) + .map(Object::toString) + .orElse(null); + 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(monitorQuery -> decompose(monitorQuery, payload)) + .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 -> + solrInputDocument.forEach( + field -> { + if (!MonitorFields.RESERVED_MONITOR_FIELDS.contains(field.getName())) { + child.addField(field.getName(), field.getValue()); + } + })); + solrInputDocument + .getChildDocuments() + .forEach( + child -> + child.setField( + indexSchema.getUniqueKeyField().getName(), + 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 firstBornInputField : firstChild) { + parent.setField(firstBornInputField.getName(), firstBornInputField.getValue()); + } + } + + private Stream decompose(MonitorQuery monitorQuery, String payload) { + return QCEVisitor.decompose(monitorQuery, decomposer).stream() + .map( + qce -> { + Document doc = + presearcher.indexQuery(qce.getMatchQuery(), monitorQuery.getMetadata()); + doc.add(monitorSchemaFields.getQueryId().createField(qce.getQueryId())); + doc.add(monitorSchemaFields.getCacheId().createField(qce.getCacheId())); + doc.add( + monitorSchemaFields.getMonitorQuery().createField(monitorQuery.getQueryString())); + if (payload != null) { + doc.add(monitorSchemaFields.getPayload().createField(payload)); + } + 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/monitor/src/test-files/monitor/BigDisjunctionQuery.xml b/solr/modules/monitor/src/test-files/monitor/BigDisjunctionQuery.xml new file mode 100644 index 000000000000..49d26cece00e --- /dev/null +++ b/solr/modules/monitor/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/monitor/src/test-files/monitor/dangling-test-single-doc-batch.json b/solr/modules/monitor/src/test-files/monitor/dangling-test-single-doc-batch.json new file mode 100644 index 000000000000..46be81547e4e --- /dev/null +++ b/solr/modules/monitor/src/test-files/monitor/dangling-test-single-doc-batch.json @@ -0,0 +1,10 @@ +{ + "params": { + "monitorDocuments": [ + { + "id": "0", + "content1_s": "lift" + } + ] + } +} \ No newline at end of file diff --git a/solr/modules/monitor/src/test-files/monitor/multi-doc-batch.json b/solr/modules/monitor/src/test-files/monitor/multi-doc-batch.json new file mode 100644 index 000000000000..c22064ef098b --- /dev/null +++ b/solr/modules/monitor/src/test-files/monitor/multi-doc-batch.json @@ -0,0 +1,28 @@ +{ + "params": { + "monitorDocuments": [ + { + "id": "0", + "content_s": "elevator stairs" + }, + { + "id": "1", + "content_s": "something else" + }, + { + "id": "2", + "content_s": "more weird content", + "other_content_s": "solr is cool" + }, + { + "id": "3", + "content_s": "test test test", + "other_content_s": "I'm tired" + }, + { + "id": "4", + "content_s": "test test test" + } + ] + } +} \ No newline at end of file diff --git a/solr/modules/monitor/src/test-files/monitor/single-doc-batch.json b/solr/modules/monitor/src/test-files/monitor/single-doc-batch.json new file mode 100644 index 000000000000..d73dd5d0d0f1 --- /dev/null +++ b/solr/modules/monitor/src/test-files/monitor/single-doc-batch.json @@ -0,0 +1,12 @@ +{ + "params": { + "monitorDocuments": [ + { + "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/monitor/src/test-files/solr/collection1/core.properties b/solr/modules/monitor/src/test-files/solr/collection1/core.properties new file mode 100644 index 000000000000..b0ef0785a797 --- /dev/null +++ b/solr/modules/monitor/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/monitor/src/test-files/solr/collection1/schema-stored-mq.xml b/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml new file mode 100644 index 000000000000..2076c6923b1a --- /dev/null +++ b/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml @@ -0,0 +1,99 @@ + + + + + + id + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/solr/modules/monitor/src/test-files/solr/collection1/schema.xml b/solr/modules/monitor/src/test-files/solr/collection1/schema.xml new file mode 100644 index 000000000000..c3bfe74ab267 --- /dev/null +++ b/solr/modules/monitor/src/test-files/solr/collection1/schema.xml @@ -0,0 +1,101 @@ + + + + + + id + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml new file mode 100644 index 000000000000..576011cc5969 --- /dev/null +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml @@ -0,0 +1,191 @@ + + + + + 9.4 + + ${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 + 10 + id + + + reverseSearch + + + + + explicit + json + true + id + + + + + explicit + + + + + 0 + false + xml + _version_ + + + + + 0 + /pingQuery + + + all + + + + + 16 + + + text_general + + + + + true + + + tvComponent + + + + + + true + false + + + terms + tvComponent + + + + string + + + + + explicit + + + elevator + + + + + + + + TermFilteredPresearcher + + + + + text/plain; charset=UTF-8 + + + ${velocity.template.base.dir:} + ${velocity.solr.resource.loader.enabled:true} + ${velocity.params.resource.loader.enabled:false} + + + + + diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml new file mode 100644 index 000000000000..c9d5dc2156a9 --- /dev/null +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml @@ -0,0 +1,190 @@ + + + + + 9.4 + + ${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 + 10 + id + + + reverseSearch + + + + + explicit + json + true + id + + + + + explicit + + + + + 0 + false + xml + _version_ + + + + + 0 + /pingQuery + + + all + + + + + + text_general + + + + + true + + + tvComponent + + + + + + true + false + + + terms + tvComponent + + + + string + + + + + explicit + + + elevator + + + + + + + + TermFilteredPresearcher + + + + + text/plain; charset=UTF-8 + + + ${velocity.template.base.dir:} + ${velocity.solr.resource.loader.enabled:true} + ${velocity.params.resource.loader.enabled:false} + + + + + diff --git a/solr/modules/monitor/src/test-files/solr/solr.xml b/solr/modules/monitor/src/test-files/solr/solr.xml new file mode 100644 index 000000000000..af58afdeb320 --- /dev/null +++ b/solr/modules/monitor/src/test-files/solr/solr.xml @@ -0,0 +1,28 @@ + + + + + + cores/ + + + ${urlScheme:} + + \ No newline at end of file diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java new file mode 100644 index 000000000000..904716fa2e9d --- /dev/null +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java @@ -0,0 +1,444 @@ +/* + * + * * 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.monitor; + +import static org.apache.solr.monitor.MonitorConstants.MONITOR_DOCUMENTS_KEY; +import static org.apache.solr.monitor.MonitorConstants.MONITOR_OUTPUT_KEY; +import static org.apache.solr.monitor.MonitorConstants.MONITOR_QUERIES_KEY; +import static org.apache.solr.monitor.MonitorConstants.REVERSE_SEARCH_PARAM_NAME; +import static org.apache.solr.monitor.MonitorConstants.WRITE_TO_DOC_LIST_KEY; + +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 java.util.Map; +import java.util.stream.IntStream; +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 MonitorSolrQueryTest extends BaseDistributedSearchTestCase { + + @Test + @ShardsFixed(num = 3) + public void testMonitorQuery() throws Exception { + del("*:*"); + index(id, Integer.toString(0), "_mq", "content_s:\"elevator music\""); + index( + id, + Integer.toString(1), + "_mq", + "{!xmlparser}steep stairs"); + index(id, Integer.toString(2), "_mq", "content_s:\"elevator sounds\""); + index(id, Integer.toString(3), "_mq", "content_s:\"elevator drop\""); + index(id, Integer.toString(4), "_mq", "content_s:\"elevator stairs\""); + index(id, Integer.toString(5), "_mq", "other_content_s:\"solr is cool\""); + index(id, Integer.toString(6), "_mq", "other_content_s:\"solr is lame\""); + index(id, Integer.toString(7), "_mq", "content_s:something", "_mq_payload", "some metadata"); + commit(); + handle.clear(); + handle.put("responseHeader", SKIP); + handle.put("response", SKIP); + + Object[] params = + new Object[] { + CommonParams.SORT, + "_query_id desc", + CommonParams.JSON, + read("/monitor/multi-doc-batch.json"), + REVERSE_SEARCH_PARAM_NAME, + true + }; + QueryResponse response = query(params); + System.out.println("Response = " + response); + validate(response, 0, 0, "1"); + validate(response, 0, 1, "4"); + validate(response, 1, 0, "7"); + validate(response, 2, 0, "5"); + assertEquals(0, ((SolrDocumentList) response.getResponse().get("response")).size()); + + index(id, Integer.toString(5), "_mq", "other_content_s:\"solr is lame\""); + index(id, Integer.toString(6), "_mq", "other_content_s:\"solr is cool\""); + index( + id, + Integer.toString(1), + "_mq", + "{!xmlparser}steep hill"); + index(id, Integer.toString(2), "_mq", "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/multi-doc-batch.json"), + REVERSE_SEARCH_PARAM_NAME, + true, + WRITE_TO_DOC_LIST_KEY, + supportsWriteToDocList() + }; + response = query(params); + System.out.println("Response = " + response); + validate(response, 0, 0, "2"); + validate(response, 0, 1, "4"); + validate(response, 1, 0, "7"); + validate(response, 2, 0, "6"); + if (supportsWriteToDocList()) { + assertEquals(4, ((SolrDocumentList) response.getResponse().get("response")).size()); + } + } + + @Test + @ShardsFixed(num = 3) + public void testNoDocListInResponse() throws Exception { + del("*:*"); + index(id, Integer.toString(0), "_mq", "content_s:\"elevator music\""); + index( + id, + Integer.toString(1), + "_mq", + "{!xmlparser}steep stairs"); + index(id, Integer.toString(2), "_mq", "content_s:\"elevator sounds\""); + index(id, Integer.toString(3), "_mq", "content_s:\"elevator drop\""); + index(id, Integer.toString(4), "_mq", "content_s:\"elevator stairs\""); + index(id, Integer.toString(5), "_mq", "other_content_s:\"solr is cool\""); + index(id, Integer.toString(6), "_mq", "other_content_s:\"solr is lame\""); + index(id, Integer.toString(7), "_mq", "content_s:something"); + commit(); + handle.clear(); + handle.put("responseHeader", SKIP); + handle.put("response", SKIP); + + Object[] params = + new Object[] { + CommonParams.SORT, + "_query_id desc", + CommonParams.JSON, + read("/monitor/multi-doc-batch.json"), + REVERSE_SEARCH_PARAM_NAME, + true, + WRITE_TO_DOC_LIST_KEY, + false + }; + QueryResponse response = query(params); + System.out.println("Response = " + response); + validate(response, 0, 0, "1"); + validate(response, 0, 1, "4"); + validate(response, 1, 0, "7"); + validate(response, 2, 0, "5"); + assertEquals(0, ((SolrDocumentList) response.getResponse().get("response")).size()); + } + + @Test + @ShardsFixed(num = 1) + public void testDefaultParser() throws Exception { + del("*:*"); + index(id, Integer.toString(0), "_mq", "content_s:\"elevator stairs\""); + index(id, Integer.toString(1), "_mq", "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-doc-batch.json"), + REVERSE_SEARCH_PARAM_NAME, + true, + WRITE_TO_DOC_LIST_KEY, + supportsWriteToDocList() + }; + + QueryResponse response = query(params); + System.out.println("Response = " + response); + validate(response, 0, 0, "0"); + validate(response, 1, 0, "1"); + } + + @Test + @ShardsFixed(num = 1) + public void testDisjunctionQuery() throws Exception { + del("*:*"); + index( + id, + Integer.toString(0), + "_mq", + "{!xmlparser}elevatorwindastufen"); + index( + id, + Integer.toString(1), + "_mq", + "{!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/single-doc-batch.json"), + REVERSE_SEARCH_PARAM_NAME, + true, + WRITE_TO_DOC_LIST_KEY, + supportsWriteToDocList() + }; + + QueryResponse response = query(params); + System.out.println("Response = " + response); + if (supportsWriteToDocList()) { + assertEquals(3, ((SolrDocumentList) response.getResponse().get("response")).size()); + } + validate(response, 0, 0, "0"); + } + + @Test + @ShardsFixed(num = 1) + public void testNoDanglingDecomposition() throws Exception { + del("*:*"); + index( + id, + Integer.toString(0), + "_mq", + "{!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"), + REVERSE_SEARCH_PARAM_NAME, + true, + WRITE_TO_DOC_LIST_KEY, + supportsWriteToDocList() + }; + + QueryResponse response = query(params); + System.out.println("Response = " + response); + if (supportsWriteToDocList()) { + assertEquals(1, ((SolrDocumentList) response.getResponse().get("response")).size()); + } + validate(response, 0, 0, "0"); + + index( + id, + Integer.toString(0), + "_mq", + "{!xmlparser}elevator"); + commit(); + response = query(params); + System.out.println("Response = " + response); + if (supportsWriteToDocList()) { + assertEquals(0, ((SolrDocumentList) response.getResponse().get("response")).size()); + } + validateEmpty(response, 0); + } + + @Test + @ShardsFixed(num = 1) + public void testNotQuery() throws Exception { + del("*:*"); + index(id, Integer.toString(0), "_mq", "*:* -content_s:\"elevator stairs\""); + index(id, Integer.toString(1), "_mq", "*:* -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/single-doc-batch.json"), + REVERSE_SEARCH_PARAM_NAME, + true, + WRITE_TO_DOC_LIST_KEY, + supportsWriteToDocList() + }; + + QueryResponse response = query(params); + System.out.println("Response = " + response); + validate(response, 0, 1, "1"); + } + + @Test + @ShardsFixed(num = 1) + public void testWildCardQuery() throws Exception { + del("*:*"); + index(id, Integer.toString(0), "_mq", "content_s:te*"); + index(id, Integer.toString(1), "_mq", "content_s:tes*"); + index(id, Integer.toString(2), "_mq", "content_s:test*"); + index(id, Integer.toString(3), "_mq", "content_s:tex*"); + index(id, Integer.toString(4), "_mq", "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-doc-batch.json"), + REVERSE_SEARCH_PARAM_NAME, + true, + WRITE_TO_DOC_LIST_KEY, + supportsWriteToDocList() + }; + + QueryResponse response = query(params); + if (supportsWriteToDocList()) { + assertEquals(3, ((SolrDocumentList) response.getResponse().get("response")).size()); + } + System.out.println("Response = " + response); + validate(response, 3, 0, "0"); + validate(response, 3, 1, "1"); + validate(response, 3, 2, "2"); + validate(response, 4, 0, "0"); + validate(response, 4, 1, "1"); + validate(response, 4, 2, "2"); + } + + @Test + @ShardsFixed(num = 1) + public void manySegmentsQuery() throws Exception { + del("*:*"); + int count = 10_000; + IntStream.range(0, count) + .forEach( + i -> { + try { + index(id, Integer.toString(i), "_mq", "content_s:\"elevator stairs\""); + } catch (Exception e) { + throw new IllegalStateException(e); + } + }); + commit(); + handle.clear(); + handle.put("responseHeader", SKIP); + handle.put("response", SKIP); + + Object[] params = + new Object[] { + CommonParams.SORT, + id + " desc", + CommonParams.JSON, + read("/monitor/multi-doc-batch.json"), + REVERSE_SEARCH_PARAM_NAME, + true + }; + + QueryResponse response = query(params); + validate(response, 0, 0, "0"); + assertEquals(count, ((Map) response.getResponse().get("monitor")).get("queriesRun")); + assertEquals( + count, + ((List) + ((Map) + ((Map) + ((Map) response.getResponse().get("monitor")) + .get("monitorDocuments")) + .get(0)) + .get("queries")) + .size()); + + IntStream.range(count / 2, count) + .forEach( + i -> { + try { + index(id, Integer.toString(i), "_mq", "content_s:\"x y\""); + } catch (Exception e) { + throw new IllegalStateException(e); + } + }); + commit(); + + response = query(params); + validate(response, 0, 0, "0"); + assertEquals(count / 2, ((Map) response.getResponse().get("monitor")).get("queriesRun")); + assertEquals( + count / 2, + ((List) + ((Map) + ((Map) + ((Map) response.getResponse().get("monitor")) + .get("monitorDocuments")) + .get(0)) + .get("queries")) + .size()); + } + + void validate(QueryResponse response, int doc, int query, Object expectedValue) { + var monitorQueries = monitorQueries(response, doc); + assertTrue(monitorQueries.size() > query); + assertEquals(expectedValue, monitorQueries.get(query)); + } + + void validateEmpty(QueryResponse response, int doc) { + var monitorQueries = monitorQueries(response, doc); + assertTrue(monitorQueries.isEmpty()); + } + + private List monitorQueries(QueryResponse response, int doc) { + assertTrue(response.getResponse().get(MONITOR_OUTPUT_KEY) instanceof Map); + assertTrue( + ((Map) response.getResponse().get(MONITOR_OUTPUT_KEY)).get(MONITOR_DOCUMENTS_KEY) + instanceof Map); + Map monitorDocuments = + (Map) + ((Map) response.getResponse().get(MONITOR_OUTPUT_KEY)).get(MONITOR_DOCUMENTS_KEY); + assertTrue(monitorDocuments.get(doc) instanceof Map); + var nthDoc = (Map) monitorDocuments.get(doc); + assertTrue(nthDoc.get(MONITOR_QUERIES_KEY) instanceof List); + return (List) nthDoc.get(MONITOR_QUERIES_KEY); + } + + protected String read(String resourceName) throws IOException, URISyntaxException { + final URL url = getClass().getResource(resourceName); + return Files.readString(Path.of(url.toURI()), StandardCharsets.UTF_8); + } + + protected boolean supportsWriteToDocList() { + return true; + } +} diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java new file mode 100644 index 000000000000..20352989bed0 --- /dev/null +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java @@ -0,0 +1,35 @@ +/* + * + * * 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.monitor; + +import org.junit.BeforeClass; + +public class ParallelMonitorSolrQueryTest extends MonitorSolrQueryTest { + + @BeforeClass + public static void beforeSuperClass() { + configString = "solrconfig-parallel.xml"; + } + + @Override + protected boolean supportsWriteToDocList() { + return false; + } +} diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java new file mode 100644 index 000000000000..b60ae9bcb4c4 --- /dev/null +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java @@ -0,0 +1,40 @@ +/* + * + * * 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.monitor; + +import org.junit.BeforeClass; +import org.junit.Test; + +public class StoredMonitorSolrQueryTest extends MonitorSolrQueryTest { + + @BeforeClass + public static void beforeSuperClass() { + schemaString = "schema-stored-mq.xml"; + } + + @Test + @ShardsFixed(num = 1) + public void indexBigQueryTest() throws Exception { + del("*:*"); + index( + id, Integer.toString(0), "_mq", "{!xmlparser}" + read("/monitor/BigDisjunctionQuery.xml")); + commit(); + } +} From fe3b4132b87574005e92efbe2d421334f50fd905 Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Mon, 1 Apr 2024 09:18:26 -0400 Subject: [PATCH 02/85] move MonitorDataValues and check in license --- solr/licenses/lucene-monitor-9.10.0.jar.sha1 | 1 + .../solr/monitor/MonitorDataValues.java | 85 +++++++++++++++++++ 2 files changed, 86 insertions(+) create mode 100644 solr/licenses/lucene-monitor-9.10.0.jar.sha1 create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java diff --git a/solr/licenses/lucene-monitor-9.10.0.jar.sha1 b/solr/licenses/lucene-monitor-9.10.0.jar.sha1 new file mode 100644 index 000000000000..0f5d66f4979a --- /dev/null +++ b/solr/licenses/lucene-monitor-9.10.0.jar.sha1 @@ -0,0 +1 @@ +082f2fce3e8f0cb84054eeb91d7a35e558f3d7be diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java new file mode 100644 index 000000000000..bd2ddfbc09b5 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java @@ -0,0 +1,85 @@ +/* + * + * * 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.monitor; + +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.MonitorFields; +import org.apache.lucene.search.DocIdSetIterator; + +public class MonitorDataValues { + + private SortedDocValues queryIdIt; + private SortedDocValues cacheIdIt; + private SortedDocValues mqIt; + private SortedDocValues payloadIt; + private NumericDocValues versionIt; + private int currentDoc = DocIdSetIterator.NO_MORE_DOCS; + private LeafReader reader; + + public void update(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); + payloadIt = reader.getSortedDocValues(MonitorFields.PAYLOAD); + versionIt = reader.getNumericDocValues(MonitorFields.VERSION); + currentDoc = DocIdSetIterator.NO_MORE_DOCS; + } + + public void advanceTo(int doc) { + currentDoc = doc; + } + + public String getQueryId() throws IOException { + queryIdIt.advanceExact(currentDoc); + return queryIdIt.lookupOrd(queryIdIt.ordValue()).utf8ToString(); + } + + public String getCacheId() throws IOException { + cacheIdIt.advanceExact(currentDoc); + 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 String getPayload() throws IOException { + if (payloadIt != null) { + if (payloadIt.advanceExact(currentDoc)) { + return payloadIt.lookupOrd(payloadIt.ordValue()).utf8ToString(); + } + return null; + } + return reader.document(currentDoc).get(MonitorFields.PAYLOAD); + } + + public long getVersion() throws IOException { + versionIt.advanceExact(currentDoc); + return versionIt.longValue(); + } +} From 0989f1c9d2e6a8fb3909423aa2ff1d3b91aa9a0a Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Mon, 1 Apr 2024 09:33:26 -0400 Subject: [PATCH 03/85] update versions.lock --- versions.lock | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/versions.lock b/versions.lock index 8ca94aa76892..3a9eba03acb1 100644 --- a/versions.lock +++ b/versions.lock @@ -209,7 +209,7 @@ org.apache.logging.log4j:log4j-jul:2.21.0 (1 constraints: 3705363b) org.apache.logging.log4j:log4j-layout-template-json:2.21.0 (1 constraints: 3705363b) org.apache.logging.log4j:log4j-slf4j2-impl:2.21.0 (1 constraints: 3705363b) org.apache.logging.log4j:log4j-web:2.21.0 (1 constraints: 3705363b) -org.apache.lucene:lucene-analysis-common:9.10.0 (10 constraints: 96a0f715) +org.apache.lucene:lucene-analysis-common:9.10.0 (11 constraints: d4ae6cc0) org.apache.lucene:lucene-analysis-icu:9.10.0 (1 constraints: 3c05593b) org.apache.lucene:lucene-analysis-kuromoji:9.10.0 (1 constraints: 3c05593b) org.apache.lucene:lucene-analysis-morfologik:9.10.0 (1 constraints: 3c05593b) @@ -221,13 +221,14 @@ org.apache.lucene:lucene-analysis-stempel:9.10.0 (1 constraints: 3c05593b) org.apache.lucene:lucene-backward-codecs:9.10.0 (1 constraints: 3c05593b) org.apache.lucene:lucene-classification:9.10.0 (1 constraints: 3c05593b) org.apache.lucene:lucene-codecs:9.10.0 (3 constraints: 2626bd9c) -org.apache.lucene:lucene-core:9.10.0 (26 constraints: 8d94ec8e) +org.apache.lucene:lucene-core:9.10.0 (27 constraints: cba2fc23) org.apache.lucene:lucene-expressions:9.10.0 (1 constraints: 3c05593b) org.apache.lucene:lucene-grouping:9.10.0 (2 constraints: 3e16d907) org.apache.lucene:lucene-highlighter:9.10.0 (1 constraints: 3c05593b) org.apache.lucene:lucene-join:9.10.0 (1 constraints: 3c05593b) -org.apache.lucene:lucene-memory:9.10.0 (1 constraints: c60f6a93) +org.apache.lucene:lucene-memory:9.10.0 (2 constraints: 041e6a79) org.apache.lucene:lucene-misc:9.10.0 (1 constraints: 3c05593b) +org.apache.lucene:lucene-monitor:9.10.0 (1 constraints: 3c05593b) org.apache.lucene:lucene-queries:9.10.0 (6 constraints: c25289f5) org.apache.lucene:lucene-queryparser:9.10.0 (1 constraints: 3c05593b) org.apache.lucene:lucene-sandbox:9.10.0 (1 constraints: fa0f1797) From 62ddcbce31163417bd951c80504f345130199d54 Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Mon, 1 Apr 2024 09:52:26 -0400 Subject: [PATCH 04/85] add package-info to monitor packages --- .../solr/monitor/cache/package-info.java | 21 +++++++++++++++++++ .../org/apache/solr/monitor/package-info.java | 21 +++++++++++++++++++ .../solr/monitor/search/package-info.java | 21 +++++++++++++++++++ .../solr/monitor/update/package-info.java | 21 +++++++++++++++++++ 4 files changed, 84 insertions(+) create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/cache/package-info.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/package-info.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/package-info.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/update/package-info.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/package-info.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/package-info.java new file mode 100644 index 000000000000..047ad946acdf --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/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.monitor.cache; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/package-info.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/package-info.java new file mode 100644 index 000000000000..7c825386a327 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/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.monitor; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/package-info.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/package-info.java new file mode 100644 index 000000000000..fa70d0d1b745 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/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.monitor.search; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/package-info.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/package-info.java new file mode 100644 index 000000000000..f6e0586056a9 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/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.monitor.update; From 33eccf761bb7bef0215aadd025daf6c42bd2150d Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Mon, 1 Apr 2024 19:29:33 -0400 Subject: [PATCH 05/85] extract helper method --- .../SharedMonitorCacheLatestRegenerator.java | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java index 43721217b6fc..74775bda44ed 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java @@ -25,6 +25,7 @@ import org.apache.lucene.monitor.MonitorDataValues; import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.search.IndexSearcher; +import org.apache.lucene.search.Query; import org.apache.solr.monitor.SolrMonitorQueryDecoder; import org.apache.solr.search.CacheRegenerator; import org.apache.solr.search.SolrCache; @@ -53,10 +54,7 @@ public boolean regenerateItem( int batchSize = Math.min(MAX_BATCH_SIZE, cache.getInitialSize()); var topDocs = new IndexSearcher(searcher.getTopReaderContext()) - .search( - LongPoint.newRangeQuery( - MonitorFields.VERSION, cache.versionHighWaterMark, Long.MAX_VALUE), - batchSize) + .search(versionRangeQuery(cache), batchSize) .scoreDocs; int batchesRemaining = cache.getInitialSize() / batchSize; while (topDocs.length > 0 && batchesRemaining > 0) { @@ -81,14 +79,15 @@ public boolean regenerateItem( var scoreDoc = topDocs[topDocs.length - 1]; topDocs = new IndexSearcher(searcher.getTopReaderContext()) - .searchAfter( - scoreDoc, - LongPoint.newRangeQuery( - MonitorFields.VERSION, cache.versionHighWaterMark, Long.MAX_VALUE), - batchSize) + .searchAfter(scoreDoc, versionRangeQuery(cache), batchSize) .scoreDocs; batchesRemaining--; } return false; } + + private static Query versionRangeQuery(SharedMonitorCache cache) { + return LongPoint.newRangeQuery( + MonitorFields.VERSION, cache.versionHighWaterMark, Long.MAX_VALUE); + } } From fa7fb4098bf4df943280b17df603c8ab5662a85d Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Wed, 3 Apr 2024 17:06:14 -0400 Subject: [PATCH 06/85] apply errorprone suggestions --- .../org/apache/lucene/monitor/CollectingMatcherProxy.java | 3 +++ .../apache/solr/monitor/search/ReverseQueryParser.java | 8 +++++--- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/CollectingMatcherProxy.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/CollectingMatcherProxy.java index 7bc5eb1c7a83..509c76dc96b6 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/CollectingMatcherProxy.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/CollectingMatcherProxy.java @@ -33,6 +33,7 @@ public CollectingMatcherProxy(IndexSearcher searcher, ScoreMode scoreMode) { super(searcher, scoreMode); } + @Override public void matchQuery(String queryId, Query matchQuery, Map metadata) { try { super.matchQuery(queryId, matchQuery, metadata); @@ -41,6 +42,7 @@ public void matchQuery(String queryId, Query matchQuery, Map met } } + @Override public MultiMatchingQueries finish(int queryCount) { return super.finish(Long.MIN_VALUE, queryCount); } @@ -51,6 +53,7 @@ protected void consumeMatch(String queryId, int batchDocId) throws IOException { } } + @Override public void setNextMatchConsumer(SingleMatchConsumer singleMatchConsumer) { this.singleMatchConsumer = singleMatchConsumer; } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParser.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParser.java index 2cb4df1a103e..88584bfe95db 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParser.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParser.java @@ -36,8 +36,6 @@ public class ReverseQueryParser extends QParser { - private static final BiPredicate ALL_TERM_ACCEPTOR = (__, ___) -> true; - private final Presearcher presearcher; public ReverseQueryParser( @@ -65,8 +63,12 @@ private BiPredicate getTermAcceptor() { var searcher = req.getSearcher(); MonitorQueryCache cache = (MonitorQueryCache) searcher.getCache(SOLR_MONITOR_CACHE_NAME); if (cache == null) { - return ALL_TERM_ACCEPTOR; + return ReverseQueryParser::allTermAcceptor; } return cache::acceptTerm; } + + private static boolean allTermAcceptor(String __, BytesRef ___) { + return true; + } } From 11a113893614715aa7f3b416b92861473eefe7fb Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Thu, 4 Apr 2024 17:18:57 -0400 Subject: [PATCH 07/85] implement highlight matches --- .../lucene/monitor/AggregatingMatcher.java | 24 +- .../monitor/CollectingMatcherProxy.java | 8 +- .../lucene/monitor/HighlightMatcherProxy.java | 83 ++++++ .../apache/lucene/monitor/MatcherProxy.java | 4 +- .../apache/solr/monitor/MonitorConstants.java | 2 + .../search/ParallelSolrMatcherSink.java | 15 +- .../search/QueryMatchResponseCodec.java | 157 +++++++--- .../solr/monitor/search/QueryMatchType.java | 13 +- .../search/ReverseSearchComponent.java | 20 +- .../search/SolrMatcherSinkFactory.java | 49 ++- .../monitor/multi-doc-batch-multi-valued.json | 15 + .../single-doc-batch-multi-valued.json | 11 + .../solr/collection1/schema-stored-mq.xml | 7 +- .../test-files/solr/collection1/schema.xml | 7 +- .../solr/monitor/MonitorSolrQueryTest.java | 282 +++++++++++++++--- 15 files changed, 581 insertions(+), 116 deletions(-) create mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/HighlightMatcherProxy.java create mode 100644 solr/modules/monitor/src/test-files/monitor/multi-doc-batch-multi-valued.json create mode 100644 solr/modules/monitor/src/test-files/monitor/single-doc-batch-multi-valued.json diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/AggregatingMatcher.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/AggregatingMatcher.java index 37fde6c0f78d..68a4f64ebd5b 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/AggregatingMatcher.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/AggregatingMatcher.java @@ -20,17 +20,21 @@ import java.util.List; import java.util.Map; +import java.util.function.BiFunction; +import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; public class AggregatingMatcher extends CandidateMatcher { - private final CandidateMatcher collector; + private final BiFunction resolver; - private AggregatingMatcher(List> matchers, CandidateMatcher collector) { - super(collector.searcher); - this.collector = collector; - for (var matcher : matchers) { - MultiMatchingQueries matches = matcher.finish(0, 0); + private AggregatingMatcher( + List> multiMatches, + IndexSearcher searcher, + BiFunction resolver) { + super(searcher); + this.resolver = resolver; + for (var matches : multiMatches) { for (int doc = 0; doc < matches.getBatchSize(); doc++) { for (T match : matches.getMatches(doc)) { this.addMatch(match, doc); @@ -53,11 +57,13 @@ public MultiMatchingQueries finish(int queryCount) { @Override public T resolve(T match1, T match2) { - return collector.resolve(match1, match2); + return resolver.apply(match1, match2); } public static AggregatingMatcher build( - List> matchers, CandidateMatcher collector) { - return new AggregatingMatcher<>(matchers, collector); + List> matchingQueries, + IndexSearcher searcher, + BiFunction resolver) { + return new AggregatingMatcher<>(matchingQueries, searcher, resolver); } } diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/CollectingMatcherProxy.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/CollectingMatcherProxy.java index 509c76dc96b6..ea1a29b23418 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/CollectingMatcherProxy.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/CollectingMatcherProxy.java @@ -28,6 +28,7 @@ public abstract class CollectingMatcherProxy extends Colle implements MatcherProxy { private SingleMatchConsumer singleMatchConsumer; + private MultiMatchingQueries cachedResult; public CollectingMatcherProxy(IndexSearcher searcher, ScoreMode scoreMode) { super(searcher, scoreMode); @@ -44,7 +45,8 @@ public void matchQuery(String queryId, Query matchQuery, Map met @Override public MultiMatchingQueries finish(int queryCount) { - return super.finish(Long.MIN_VALUE, queryCount); + cachedResult = super.finish(Long.MIN_VALUE, queryCount); + return cachedResult; } protected void consumeMatch(String queryId, int batchDocId) throws IOException { @@ -59,7 +61,7 @@ public void setNextMatchConsumer(SingleMatchConsumer singleMatchConsumer) { } @Override - public CandidateMatcher matcher() { - return this; + public MultiMatchingQueries matches() { + return cachedResult; } } diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/HighlightMatcherProxy.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/HighlightMatcherProxy.java new file mode 100644 index 000000000000..de948fc2eb2d --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/HighlightMatcherProxy.java @@ -0,0 +1,83 @@ +/* + * + * * 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 org.apache.lucene.search.IndexSearcher; +import org.apache.lucene.search.Query; + +public class HighlightMatcherProxy implements MatcherProxy { + + private final List> multiMatchingQueries = + new ArrayList<>(); + private final IndexSearcher indexSearcher; + private final CandidateMatcher resolverMatcher; + private SingleMatchConsumer singleMatchConsumer; + private MultiMatchingQueries cachedResult; + + public HighlightMatcherProxy(IndexSearcher indexSearcher) { + this.indexSearcher = indexSearcher; + this.resolverMatcher = HighlightsMatch.MATCHER.createMatcher(indexSearcher); + } + + @Override + public void matchQuery(String queryId, Query matchQuery, Map metadata) { + try { + var highlightMatcher = HighlightsMatch.MATCHER.createMatcher(indexSearcher); + highlightMatcher.matchQuery(queryId, matchQuery, metadata); + var matchingQueries = highlightMatcher.finish(0, 0); + this.multiMatchingQueries.add(matchingQueries); + if (singleMatchConsumer != null) { + for (int i = 0; i < matchingQueries.getBatchSize(); i++) { + if (!matchingQueries.getMatches(i).isEmpty()) { + singleMatchConsumer.accept(queryId, i); + } + } + } + } catch (IOException e) { + throw new IllegalStateException("This should be impossible for an in-memory searcher", e); + } + } + + @Override + public MultiMatchingQueries finish(int queryCount) { + var aggregator = AggregatingMatcher.build(multiMatchingQueries, indexSearcher, this::resolve); + cachedResult = aggregator.finish(queryCount); + return cachedResult; + } + + @Override + public void setNextMatchConsumer(SingleMatchConsumer singleMatchConsumer) { + this.singleMatchConsumer = singleMatchConsumer; + } + + @Override + public MultiMatchingQueries matches() { + return cachedResult; + } + + @Override + public HighlightsMatch resolve(HighlightsMatch match1, HighlightsMatch match2) { + return resolverMatcher.resolve(match1, match2); + } +} diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatcherProxy.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatcherProxy.java index 592f75914331..289e8df5d5dd 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatcherProxy.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatcherProxy.java @@ -30,5 +30,7 @@ public interface MatcherProxy { void setNextMatchConsumer(SingleMatchConsumer singleMatchConsumer); - CandidateMatcher matcher(); + MultiMatchingQueries matches(); + + T resolve(T match1, T match2); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java index 9ec7c454a1ac..8b6bd37d66c2 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java @@ -30,6 +30,8 @@ private MonitorConstants() {} public static final String MONITOR_DOCUMENT_KEY = "monitorDocument"; public static final String MONITOR_QUERIES_KEY = "queries"; public static final String MONITOR_QUERIES_RUN = "queriesRun"; + public static final String QUERY_MATCH_TYPE_KEY = "monitorMatchType"; public static final String MONITOR_OUTPUT_KEY = "monitor"; public static final String WRITE_TO_DOC_LIST_KEY = "writeToDocList"; + public static final String HITS_KEY = "hits"; } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java index c9ae48ffa836..120bec21d978 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java @@ -27,10 +27,10 @@ import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorCompletionService; import java.util.concurrent.ExecutorService; +import java.util.function.BiFunction; import java.util.function.Consumer; import java.util.function.Function; import org.apache.lucene.monitor.AggregatingMatcher; -import org.apache.lucene.monitor.CandidateMatcher; import org.apache.lucene.monitor.MatcherProxy; import org.apache.lucene.monitor.MultiMatchingQueries; import org.apache.lucene.monitor.QueryMatch; @@ -40,7 +40,7 @@ class ParallelSolrMatcherSink implements SolrMatcherSink { - private final CompletionService> completionService; + private final CompletionService> completionService; private final Function> matcherProxyFactory; private final IndexSearcher docBatchSearcher; private final Consumer> queriesConsumer; @@ -67,18 +67,19 @@ public void matchQuery( () -> { var matcherProxy = matcherProxyFactory.apply(docBatchSearcher); matcherProxy.matchQuery(queryId, matchQuery, metadata); - return matcherProxy.matcher(); + matcherProxy.finish(1); + return matcherProxy.matches(); }); tasksLeft++; } @Override public void complete() throws IOException { - List> matchers = new ArrayList<>(); + List> matchingQueries = new ArrayList<>(); int queryCount = tasksLeft; while (tasksLeft-- > 0) { try { - matchers.add(completionService.take().get()); + matchingQueries.add(completionService.take().get()); } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new IOException(e); @@ -87,8 +88,8 @@ public void complete() throws IOException { MatcherProxy.class.getSimpleName() + " should never throw an exception", e); } } - var aggregatingMatcher = - AggregatingMatcher.build(matchers, matcherProxyFactory.apply(docBatchSearcher).matcher()); + BiFunction resolver = matcherProxyFactory.apply(docBatchSearcher)::resolve; + var aggregatingMatcher = AggregatingMatcher.build(matchingQueries, docBatchSearcher, resolver); queriesConsumer.accept(aggregatingMatcher.finish(queryCount)); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchResponseCodec.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchResponseCodec.java index 47537591c1c1..2db12be8f4f5 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchResponseCodec.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchResponseCodec.java @@ -28,21 +28,25 @@ import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.IntStream; import java.util.stream.Stream; +import org.apache.lucene.monitor.HighlightsMatch; +import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.monitor.MultiMatchingQueries; import org.apache.lucene.monitor.QueryMatch; import org.apache.lucene.util.BytesRef; import org.apache.solr.common.SolrException; import org.apache.solr.common.util.NamedList; +import org.apache.solr.monitor.MonitorConstants; +@SuppressWarnings("unchecked") class QueryMatchResponseCodec { - @SuppressWarnings({"unchecked"}) static Map mergeResponses( List> responses, QueryMatchType type) { Map> wrappedMerged = new HashMap<>(); @@ -78,7 +82,6 @@ static Map mergeResponses( return output; } - @SuppressWarnings({"unchecked"}) private static void decodeToWrappers( Object object, Map> output, QueryMatchType type) { if (!(object instanceof Map)) { @@ -90,26 +93,30 @@ private static void decodeToWrappers( throw new IllegalArgumentException(MONITOR_DOCUMENTS_KEY + " should be a map"); } var monitorDocuments = (Map) monitorDocumentsRaw; - if (type == QueryMatchType.SIMPLE) { - for (var docEntryRaw : monitorDocuments.values()) { - if (!(docEntryRaw instanceof Map)) { - throw new IllegalArgumentException(MONITOR_DOCUMENTS_KEY + " should contain maps"); - } - var docEntry = (Map) docEntryRaw; - Object docRaw = docEntry.get(MONITOR_DOCUMENT_KEY); - if (!(docRaw instanceof Integer)) { - throw new IllegalStateException(MONITOR_DOCUMENT_KEY + " needs to be an int"); - } - Object monitorQueriesRaw = docEntry.get(MONITOR_QUERIES_KEY); - if (!(monitorQueriesRaw instanceof List)) { - throw new IllegalStateException(MONITOR_QUERIES_KEY + " needs to be an list"); - } - int doc = (Integer) docRaw; - List wrappers = output.computeIfAbsent(doc, i -> new ArrayList<>()); - List serializableFormMQs = (List) monitorQueriesRaw; - for (var serializableForm : serializableFormMQs) { - wrappers.add(SimpleQueryMatchWrapper.fromSerializableForm(serializableForm)); - } + for (var docEntryRaw : monitorDocuments.values()) { + if (!(docEntryRaw instanceof Map)) { + throw new IllegalArgumentException(MONITOR_DOCUMENTS_KEY + " should contain maps"); + } + var docEntry = (Map) docEntryRaw; + Object docRaw = docEntry.get(MONITOR_DOCUMENT_KEY); + if (!(docRaw instanceof Integer)) { + throw new IllegalStateException(MONITOR_DOCUMENT_KEY + " needs to be an int"); + } + Object monitorQueriesRaw = docEntry.get(MONITOR_QUERIES_KEY); + if (!(monitorQueriesRaw instanceof List)) { + throw new IllegalStateException(MONITOR_QUERIES_KEY + " needs to be an list"); + } + int doc = (Integer) docRaw; + List wrappers = output.computeIfAbsent(doc, i -> new ArrayList<>()); + List serializableFormMQs = (List) monitorQueriesRaw; + if (type == QueryMatchType.SIMPLE) { + serializableFormMQs.forEach( + serializableForm -> + wrappers.add(SimpleQueryMatchWrapper.fromSerializableForm(serializableForm))); + } else if (type == QueryMatchType.HIGHLIGHTS) { + serializableFormMQs.forEach( + serializableForm -> + wrappers.add(HighlightedQueryMatchWrapper.fromSerializableForm(serializableForm))); } } } @@ -122,6 +129,14 @@ static void simpleEncode( matchingQueries, output, docBatchSize, SimpleQueryMatchWrapper::fromQueryMatch); } + static void highlightEncode( + MultiMatchingQueries matchingQueries, + Map output, + int docBatchSize) { + encodeMultiMatchingQuery( + matchingQueries, output, docBatchSize, HighlightedQueryMatchWrapper::new); + } + private static void encodeMultiMatchingQuery( MultiMatchingQueries matchingQueries, Map output, @@ -144,16 +159,33 @@ private static void encodeMultiMatchingQuery( } private static Map encodeWrappers(Stream matches, int doc) { - return Map.of( - MONITOR_DOCUMENT_KEY, - doc, + Map map = new LinkedHashMap<>(); + map.put(MONITOR_DOCUMENT_KEY, doc); + map.put( MONITOR_QUERIES_KEY, matches.sorted().map(QueryMatchWrapper::toSerializableForm).collect(Collectors.toList())); + return map; } private interface QueryMatchWrapper extends Comparable { Object toSerializableForm(); + + BytesRef queryId(); + + @Override + default int compareTo(QueryMatchWrapper o) { + if (getClass() != o.getClass()) { + throw new IllegalArgumentException( + getClass().getSimpleName() + + " can only be compared to other instances of the same concrete type"); + } + return queryId().compareTo(o.queryId()); + } + } + + static void decodingError(Object obj, Class wrapper) { + throw new IllegalArgumentException("Cannot decode " + obj + " to " + wrapper.getSimpleName()); } private static class SimpleQueryMatchWrapper implements QueryMatchWrapper { @@ -164,22 +196,13 @@ private SimpleQueryMatchWrapper(BytesRef queryId) { this.queryId = queryId; } - @Override - public int compareTo(QueryMatchWrapper o) { - if (!(o instanceof SimpleQueryMatchWrapper)) { - throw new IllegalArgumentException( - "SimpleQueryMatchWrapper can only be compared to other SimpleQueryMatchWrappers"); - } - return queryId.compareTo(((SimpleQueryMatchWrapper) o).queryId); - } - private static SimpleQueryMatchWrapper fromQueryMatch(QueryMatch queryMatch) { return new SimpleQueryMatchWrapper(new BytesRef(queryMatch.getQueryId())); } private static SimpleQueryMatchWrapper fromSerializableForm(Object serializableForm) { if (!(serializableForm instanceof String)) { - throw new IllegalArgumentException("only support decoding for String"); + decodingError(serializableForm, SimpleQueryMatchWrapper.class); } return new SimpleQueryMatchWrapper(new BytesRef((String) serializableForm)); } @@ -188,5 +211,69 @@ private static SimpleQueryMatchWrapper fromSerializableForm(Object serializableF public Object toSerializableForm() { return queryId.utf8ToString(); } + + @Override + public BytesRef queryId() { + return queryId; + } + } + + private static class HighlightedQueryMatchWrapper implements QueryMatchWrapper { + + private final BytesRef queryId; + private final Map hits; + + private HighlightedQueryMatchWrapper(HighlightsMatch highlightsMatch) { + this( + new BytesRef(highlightsMatch.getQueryId()), + highlightsMatch.getHits().entrySet().stream() + .collect( + Collectors.toMap( + Map.Entry::getKey, + entry -> + entry.getValue().stream() + .map(HighlightedQueryMatchWrapper::hitMap) + .collect(Collectors.toList())))); + } + + private static Map hitMap(HighlightsMatch.Hit hit) { + Map map = new LinkedHashMap<>(); + map.put("startPosition", hit.startPosition); + map.put("endPosition", hit.endPosition); + map.put("startOffset", hit.startOffset); + map.put("endOffset", hit.endOffset); + return map; + } + + private HighlightedQueryMatchWrapper(BytesRef queryId, Map hits) { + this.hits = hits; + this.queryId = queryId; + } + + @Override + public Object toSerializableForm() { + Map map = new LinkedHashMap<>(); + map.put(MonitorFields.QUERY_ID, queryId.utf8ToString()); + map.put(MonitorConstants.HITS_KEY, hits); + return map; + } + + private static HighlightedQueryMatchWrapper fromSerializableForm(Object serializableForm) { + if (!(serializableForm instanceof Map)) { + decodingError(serializableForm, HighlightedQueryMatchWrapper.class); + } + Object queryId = ((Map) serializableForm).get(MonitorFields.QUERY_ID); + Object hits = ((Map) serializableForm).get(MonitorConstants.HITS_KEY); + if (!(queryId instanceof String) || !(hits instanceof Map)) { + decodingError(serializableForm, HighlightedQueryMatchWrapper.class); + } + return new HighlightedQueryMatchWrapper( + new BytesRef((String) queryId), (Map) hits); + } + + @Override + public BytesRef queryId() { + return queryId; + } } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchType.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchType.java index 2b28d6c26f84..aa89a79ef9b1 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchType.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchType.java @@ -20,5 +20,16 @@ package org.apache.solr.monitor.search; public enum QueryMatchType { - SIMPLE + SIMPLE, + HIGHLIGHTS, + NONE; + + static QueryMatchType fromString(String matchType) { + if (SIMPLE.name().equalsIgnoreCase(matchType)) { + return SIMPLE; + } else if (HIGHLIGHTS.name().equalsIgnoreCase(matchType)) { + return HIGHLIGHTS; + } + return NONE; + } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index b7644167716f..85f34dc8ade3 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -22,6 +22,7 @@ import static org.apache.solr.monitor.MonitorConstants.DOCUMENT_BATCH_KEY; import static org.apache.solr.monitor.MonitorConstants.MONITOR_DOCUMENTS_KEY; import static org.apache.solr.monitor.MonitorConstants.MONITOR_OUTPUT_KEY; +import static org.apache.solr.monitor.MonitorConstants.QUERY_MATCH_TYPE_KEY; import static org.apache.solr.monitor.MonitorConstants.REVERSE_SEARCH_PARAM_NAME; import static org.apache.solr.monitor.MonitorConstants.SOLR_MONITOR_CACHE_NAME; import static org.apache.solr.monitor.MonitorConstants.WRITE_TO_DOC_LIST_KEY; @@ -90,9 +91,10 @@ public void prepare(ResponseBuilder rb) { boolean writeToDocList = Boolean.parseBoolean(writeToDocListRaw); List mutableFilters = Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); + var matchType = QueryMatchType.fromString(req.getParams().get(QUERY_MATCH_TYPE_KEY)); Map monitorResult = new HashMap<>(); - var simpleMatcherSink = solrMatcherSinkFactory.buildSimple(documentBatch, monitorResult); - if (simpleMatcherSink.isParallel() && writeToDocList) { + var matcherSink = solrMatcherSinkFactory.build(matchType, documentBatch, monitorResult); + if (matcherSink.isParallel() && writeToDocList) { throw new SolrException( ErrorCode.BAD_REQUEST, "writeToDocList is not supported for parallel matcher. Consider adding more shards/cores instead of parallel matcher."); @@ -108,9 +110,12 @@ public void prepare(ResponseBuilder rb) { mutableFilters.add( new MonitorPostFilter( new SolrMonitorQueryCollector.CollectorContext( - solrMonitorCache, queryDecoder, simpleMatcherSink, writeToDocList))); + solrMonitorCache, queryDecoder, matcherSink, writeToDocList))); rb.setFilters(mutableFilters); - rb.rsp.add(MONITOR_OUTPUT_KEY, monitorResult); + rb.rsp.add(QUERY_MATCH_TYPE_KEY, matchType.name()); + if (matchType != QueryMatchType.NONE) { + rb.rsp.add(MONITOR_OUTPUT_KEY, monitorResult); + } } catch (SyntaxError e) { throw new SolrException( SolrException.ErrorCode.BAD_REQUEST, "Syntax error in query: " + e.getMessage()); @@ -157,8 +162,11 @@ public void handleResponses(ResponseBuilder rb, ShardRequest sreq) { .map(shardResponse -> shardResponse.getSolrResponse().getResponse()) .collect(Collectors.toList()); rb.rsp.getValues().removeAll(MONITOR_OUTPUT_KEY); - var finalOutput = mergeResponses(responses, QueryMatchType.SIMPLE); - rb.rsp.add(MONITOR_OUTPUT_KEY, finalOutput); + var matchType = QueryMatchType.fromString(rb.req.getParams().get(QUERY_MATCH_TYPE_KEY)); + if (matchType != QueryMatchType.NONE) { + var finalOutput = mergeResponses(responses, matchType); + rb.rsp.add(MONITOR_OUTPUT_KEY, finalOutput); + } } @Override diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java index a1fdaf25d666..dc231e3dc17a 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java @@ -22,7 +22,9 @@ import java.util.Map; import java.util.concurrent.ExecutorService; import java.util.function.Consumer; +import java.util.function.Function; import org.apache.lucene.monitor.DocumentBatchVisitor; +import org.apache.lucene.monitor.HighlightMatcherProxy; import org.apache.lucene.monitor.MatcherProxy; import org.apache.lucene.monitor.MultiMatchingQueries; import org.apache.lucene.monitor.QueryMatch; @@ -42,22 +44,45 @@ class SolrMatcherSinkFactory { this.executorService = executorService; } - SolrMatcherSink buildSimple( - DocumentBatchVisitor documentBatch, Map monitorResult) { - Consumer> simpleEncoder = - matchingQueries -> - QueryMatchResponseCodec.simpleEncode( - matchingQueries, monitorResult, documentBatch.size()); + SolrMatcherSink build( + QueryMatchType matchType, + DocumentBatchVisitor documentBatch, + Map monitorResult) { + if (matchType == QueryMatchType.SIMPLE) { + return buildSimple( + documentBatch, + matchingQueries -> + QueryMatchResponseCodec.simpleEncode( + matchingQueries, monitorResult, documentBatch.size())); + } else if (matchType == QueryMatchType.HIGHLIGHTS) { + return build( + documentBatch, + HighlightMatcherProxy::new, + matchingQueries -> + QueryMatchResponseCodec.highlightEncode( + matchingQueries, monitorResult, documentBatch.size())); + } + return buildSimple(documentBatch, __ -> {}); + } + + private SolrMatcherSink buildSimple( + DocumentBatchVisitor documentBatch, Consumer> encoder) { + return build( + documentBatch, + searcher -> new SimpleMatcherProxy(searcher, ScoreMode.COMPLETE_NO_SCORES), + encoder); + } + + private SolrMatcherSink build( + DocumentBatchVisitor documentBatch, + Function> matcherProxyFactory, + Consumer> encoder) { var docBatchSearcher = new IndexSearcher(documentBatch.get()); if (executorService == null) { - return new SyncSolrMatcherSink<>(buildSimpleMatcherProxy(docBatchSearcher), simpleEncoder); + return new SyncSolrMatcherSink<>(matcherProxyFactory.apply(docBatchSearcher), encoder); } else { return new ParallelSolrMatcherSink<>( - executorService, this::buildSimpleMatcherProxy, docBatchSearcher, simpleEncoder); + executorService, matcherProxyFactory, docBatchSearcher, encoder); } } - - private MatcherProxy buildSimpleMatcherProxy(IndexSearcher docBatchSearcher) { - return new SimpleMatcherProxy(docBatchSearcher, ScoreMode.COMPLETE_NO_SCORES); - } } diff --git a/solr/modules/monitor/src/test-files/monitor/multi-doc-batch-multi-valued.json b/solr/modules/monitor/src/test-files/monitor/multi-doc-batch-multi-valued.json new file mode 100644 index 000000000000..a5d666aa6ef8 --- /dev/null +++ b/solr/modules/monitor/src/test-files/monitor/multi-doc-batch-multi-valued.json @@ -0,0 +1,15 @@ +{ + "params": { + "monitorDocuments": [ + { + "id": "0", + "content0_offset_s": "elevator stairs", + "content0_offset_sds": ["test highlights", " on this multi-valued field"] + }, + { + "id": "1", + "content0_offset_s": "on the elevator " + } + ] + } +} \ No newline at end of file diff --git a/solr/modules/monitor/src/test-files/monitor/single-doc-batch-multi-valued.json b/solr/modules/monitor/src/test-files/monitor/single-doc-batch-multi-valued.json new file mode 100644 index 000000000000..323377476ddf --- /dev/null +++ b/solr/modules/monitor/src/test-files/monitor/single-doc-batch-multi-valued.json @@ -0,0 +1,11 @@ +{ + "params": { + "monitorDocuments": [ + { + "id": "0", + "content0_s": "elevator stairs", + "content0_sds": ["test highlights", " on this multi-valued field"] + } + ] + } +} \ No newline at end of file diff --git a/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml b/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml index 2076c6923b1a..2014e706bcf0 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml @@ -27,9 +27,10 @@ - - + + + + - - + + + + queryMatch0 = + queryMatch("0", f1, List.of(new HighlightsMatch.Hit(0, 0, 1, 15)), f2, List.of()); + Map queryMatch1 = + queryMatch( + "1", + f1, + List.of(new HighlightsMatch.Hit(0, 0, 0, 8)), + f2, + List.of( + new HighlightsMatch.Hit(1, 5, 1, 15), new HighlightsMatch.Hit(106, 38, 106, 43))); + Map queryMatch4 = + queryMatch("4", f1, List.of(new HighlightsMatch.Hit(0, 0, 0, 8)), f2, List.of()); + validate(response, 0, List.of(queryMatch0, queryMatch1, queryMatch4)); + queryMatch4 = queryMatch("4", f1, List.of(new HighlightsMatch.Hit(2, 7, 2, 15)), f2, List.of()); + validate(response, 1, List.of(queryMatch4)); + var queries = monitorQueries(response, 0); + assertEquals(3, queries.size()); + queries = monitorQueries(response, 1); + assertEquals(1, queries.size()); + if (supportsWriteToDocList()) { + assertEquals(3, ((SolrDocumentList) response.getResponse().get("response")).size()); + } + } + + @Test + @ShardsFixed(num = 1) + public void testHighlightMatchType() throws Exception { + del("*:*"); + index(id, Integer.toString(0), "_mq", "content0_s:\"elevator stairs\""); + index( + id, + Integer.toString(1), + "_mq", + "content0_sds:highlights || content0_sds:field || content0_s:elevator"); + index( + id, + Integer.toString(2), + "_mq", + "content0_sds:ignore && content0_sds:field && content0_s:elevator"); + commit(); + handle.clear(); + handle.put("responseHeader", SKIP); + handle.put("response", SKIP); + + Object[] params = + new Object[] { + CommonParams.SORT, + id + " desc", + CommonParams.JSON, + read("/monitor/single-doc-batch-multi-valued.json"), + REVERSE_SEARCH_PARAM_NAME, + true, + QUERY_MATCH_TYPE_KEY, + "highlights", + WRITE_TO_DOC_LIST_KEY, + supportsWriteToDocList() + }; + + QueryResponse response = query(params); + System.out.println("Response = " + response); + String f1 = "content0_s"; + String f2 = "content0_sds"; + + Map queryMatch0 = + queryMatch("0", f1, List.of(new HighlightsMatch.Hit(0, 0, 1, 15)), f2, List.of()); + Map queryMatch1 = + queryMatch( + "1", + f1, + List.of(new HighlightsMatch.Hit(0, 0, 0, 8)), + f2, + List.of( + new HighlightsMatch.Hit(1, 5, 1, 15), new HighlightsMatch.Hit(106, 38, 106, 43))); + validate(response, 0, List.of(queryMatch0, queryMatch1)); + var queries = monitorQueries(response, 0); + assertEquals(2, queries.size()); + if (supportsWriteToDocList()) { + // The disjuncts come in as separate matches + // TODO is this the most desirable behavior? + assertEquals(4, ((SolrDocumentList) response.getResponse().get("response")).size()); + } + } + + static Map queryMatch( + String queryId, + String field1, + List firstFieldHits, + String field2, + List secondFieldHits) { + Map queryMatch = new LinkedHashMap<>(); + queryMatch.put(MonitorFields.QUERY_ID, queryId); + Map matchHits = new LinkedHashMap<>(); + var outHits1 = map(firstFieldHits); + if (!outHits1.isEmpty()) { + matchHits.put(field1, outHits1); + } + var outHits2 = map(secondFieldHits); + if (!outHits2.isEmpty()) { + matchHits.put(field2, outHits2); + } + queryMatch.put(MonitorConstants.HITS_KEY, matchHits); + return queryMatch; + } + + static List map(List hits) { + List outHits = new ArrayList<>(); + for (var hit : hits) { + Map hit00 = new LinkedHashMap<>(); + hit00.put("startPosition", hit.startPosition); + hit00.put("endPosition", hit.endPosition); + hit00.put("startOffset", hit.startOffset); + hit00.put("endOffset", hit.endOffset); + outHits.add(hit00); + } + return outHits; + } + + void validate(QueryResponse response, int doc, Object expectedValue) { var monitorQueries = monitorQueries(response, doc); - assertTrue(monitorQueries.size() > query); - assertEquals(expectedValue, monitorQueries.get(query)); + assertEquals(expectedValue, monitorQueries); } - void validateEmpty(QueryResponse response, int doc) { + void validate(QueryResponse response, int doc, int query, Object expectedValue) { var monitorQueries = monitorQueries(response, doc); - assertTrue(monitorQueries.isEmpty()); + assertTrue(monitorQueries.size() > query); + assertEquals(expectedValue, monitorQueries.get(query)); } - private List monitorQueries(QueryResponse response, int doc) { + List monitorQueries(QueryResponse response, int doc) { assertTrue(response.getResponse().get(MONITOR_OUTPUT_KEY) instanceof Map); assertTrue( ((Map) response.getResponse().get(MONITOR_OUTPUT_KEY)).get(MONITOR_DOCUMENTS_KEY) From 7526b2fea32a532b8a9cc66d648de0c1297e93dd Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Thu, 4 Apr 2024 17:26:36 -0400 Subject: [PATCH 08/85] AggregatingMatcher -> MatchesAggregator --- .../lucene/monitor/HighlightMatcherProxy.java | 4 ++-- ...gatingMatcher.java => MatchesAggregator.java} | 16 +++++++--------- .../monitor/search/ParallelSolrMatcherSink.java | 7 ++++--- 3 files changed, 13 insertions(+), 14 deletions(-) rename solr/modules/monitor/src/java/org/apache/lucene/monitor/{AggregatingMatcher.java => MatchesAggregator.java} (83%) diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/HighlightMatcherProxy.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/HighlightMatcherProxy.java index de948fc2eb2d..6d2eebe5eb27 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/HighlightMatcherProxy.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/HighlightMatcherProxy.java @@ -61,8 +61,8 @@ public void matchQuery(String queryId, Query matchQuery, Map met @Override public MultiMatchingQueries finish(int queryCount) { - var aggregator = AggregatingMatcher.build(multiMatchingQueries, indexSearcher, this::resolve); - cachedResult = aggregator.finish(queryCount); + cachedResult = + MatchesAggregator.aggregate(multiMatchingQueries, indexSearcher, this::resolve, queryCount); return cachedResult; } diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/AggregatingMatcher.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatchesAggregator.java similarity index 83% rename from solr/modules/monitor/src/java/org/apache/lucene/monitor/AggregatingMatcher.java rename to solr/modules/monitor/src/java/org/apache/lucene/monitor/MatchesAggregator.java index 68a4f64ebd5b..b05698168694 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/AggregatingMatcher.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatchesAggregator.java @@ -24,11 +24,11 @@ import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; -public class AggregatingMatcher extends CandidateMatcher { +public class MatchesAggregator extends CandidateMatcher { private final BiFunction resolver; - private AggregatingMatcher( + private MatchesAggregator( List> multiMatches, IndexSearcher searcher, BiFunction resolver) { @@ -51,19 +51,17 @@ protected void matchQuery(String queryId, Query matchQuery, Map throw new UnsupportedOperationException("only use for aggregating other matchers"); } - public MultiMatchingQueries finish(int queryCount) { - return finish(Long.MIN_VALUE, queryCount); - } - @Override public T resolve(T match1, T match2) { return resolver.apply(match1, match2); } - public static AggregatingMatcher build( + public static MultiMatchingQueries aggregate( List> matchingQueries, IndexSearcher searcher, - BiFunction resolver) { - return new AggregatingMatcher<>(matchingQueries, searcher, resolver); + BiFunction resolver, + int queryCount) { + return new MatchesAggregator<>(matchingQueries, searcher, resolver) + .finish(Long.MIN_VALUE, queryCount); } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java index 120bec21d978..913cf398cb7a 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java @@ -30,8 +30,8 @@ import java.util.function.BiFunction; import java.util.function.Consumer; import java.util.function.Function; -import org.apache.lucene.monitor.AggregatingMatcher; import org.apache.lucene.monitor.MatcherProxy; +import org.apache.lucene.monitor.MatchesAggregator; import org.apache.lucene.monitor.MultiMatchingQueries; import org.apache.lucene.monitor.QueryMatch; import org.apache.lucene.monitor.SingleMatchConsumer; @@ -89,8 +89,9 @@ public void complete() throws IOException { } } BiFunction resolver = matcherProxyFactory.apply(docBatchSearcher)::resolve; - var aggregatingMatcher = AggregatingMatcher.build(matchingQueries, docBatchSearcher, resolver); - queriesConsumer.accept(aggregatingMatcher.finish(queryCount)); + var aggregateMatches = + MatchesAggregator.aggregate(matchingQueries, docBatchSearcher, resolver, queryCount); + queriesConsumer.accept(aggregateMatches); } @Override From 6ac7a5ef9fe549c620cf7f3a47ce651bda46b8a2 Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Thu, 4 Apr 2024 18:28:21 -0400 Subject: [PATCH 09/85] make monitor query cache optional --- .../apache/solr/monitor/MonitorConstants.java | 3 + .../solr/monitor/cache/MonitorQueryCache.java | 3 - .../monitor/cache/SharedMonitorCache.java | 11 +- .../search/SolrMonitorQueryCollector.java | 29 ++- .../update/MonitorUpdateRequestProcessor.java | 5 +- .../solr/collection1/solrconfig-no-cache.xml | 185 ++++++++++++++++++ .../solr/monitor/MonitorSolrQueryTest.java | 8 +- .../monitor/NoCacheMonitorSolrQueryTest.java | 30 +++ .../monitor/StoredMonitorSolrQueryTest.java | 1 - 9 files changed, 238 insertions(+), 37 deletions(-) create mode 100644 solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml create mode 100644 solr/modules/monitor/src/test/org/apache/solr/monitor/NoCacheMonitorSolrQueryTest.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java index 8b6bd37d66c2..91fc87af4861 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java @@ -19,6 +19,8 @@ package org.apache.solr.monitor; +import org.apache.lucene.monitor.QueryDecomposer; + public class MonitorConstants { private MonitorConstants() {} @@ -34,4 +36,5 @@ private MonitorConstants() {} public static final String MONITOR_OUTPUT_KEY = "monitor"; public static final String WRITE_TO_DOC_LIST_KEY = "writeToDocList"; public static final String HITS_KEY = "hits"; + public static final QueryDecomposer QUERY_DECOMPOSER = new QueryDecomposer(); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java index 1cb6534455dd..ac6d97f3ac7b 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java @@ -21,7 +21,6 @@ import java.io.IOException; import org.apache.lucene.monitor.MonitorDataValues; -import org.apache.lucene.monitor.QueryDecomposer; import org.apache.lucene.util.BytesRef; import org.apache.solr.monitor.SolrMonitorQueryDecoder; @@ -31,6 +30,4 @@ VersionedQueryCacheEntry computeIfStale( MonitorDataValues dataValues, SolrMonitorQueryDecoder decoder) throws IOException; boolean acceptTerm(String field, BytesRef value); - - QueryDecomposer getDecomposer(); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java index 918856e4a1db..bb5a00546d4b 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java @@ -33,13 +33,13 @@ import org.apache.lucene.monitor.MonitorDataValues; import org.apache.lucene.monitor.MonitorQuery; import org.apache.lucene.monitor.QCEVisitor; -import org.apache.lucene.monitor.QueryDecomposer; import org.apache.lucene.monitor.QueryTermFilterVisitor; import org.apache.lucene.util.BytesRef; 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.monitor.MonitorConstants; import org.apache.solr.monitor.SolrMonitorQueryDecoder; import org.apache.solr.search.CacheRegenerator; import org.apache.solr.search.SolrCache; @@ -54,7 +54,6 @@ public class SharedMonitorCache extends SolrCacheBase private static final long START_HIGH_WATER_MARK = -1; - private final QueryDecomposer queryDecomposer = new QueryDecomposer(); private final AtomicReference currentStats = new AtomicReference<>(CurrentStats.init()); @@ -87,11 +86,6 @@ public boolean acceptTerm(String field, BytesRef value) { return termAcceptor.test(field, value); } - @Override - public QueryDecomposer getDecomposer() { - return queryDecomposer; - } - private Map mqCacheMap() { return mqCache.asMap(); } @@ -271,7 +265,8 @@ private VersionedQueryCacheEntry compute( var version = dataValues.getVersion(); if (prevEntry == null || version > prevEntry.version) { var monitorQuery = decoder.apply(dataValues); - QCEVisitor component = QCEVisitor.getComponent(monitorQuery, getDecomposer(), cacheId); + QCEVisitor component = + QCEVisitor.getComponent(monitorQuery, MonitorConstants.QUERY_DECOMPOSER, cacheId); currentStats.updateAndGet(CurrentStats::miss); return new VersionedQueryCacheEntry(component, version); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java index ce216ec85506..da7626f2826d 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java @@ -26,9 +26,9 @@ import org.apache.lucene.monitor.QCEVisitor; import org.apache.lucene.monitor.SingleMatchConsumer; import org.apache.lucene.search.ScoreMode; +import org.apache.solr.monitor.MonitorConstants; import org.apache.solr.monitor.SolrMonitorQueryDecoder; import org.apache.solr.monitor.cache.MonitorQueryCache; -import org.apache.solr.monitor.cache.VersionedQueryCacheEntry; import org.apache.solr.search.DelegatingCollector; class SolrMonitorQueryCollector extends DelegatingCollector { @@ -53,24 +53,23 @@ class SolrMonitorQueryCollector extends DelegatingCollector { @Override public void collect(int doc) throws IOException { dataValues.advanceTo(doc); - var versionedEntry = monitorQueryCache.computeIfStale(dataValues, queryDecoder); - var entry = getEntry(versionedEntry, dataValues); + var entry = getEntry(dataValues); var queryId = dataValues.getQueryId(); var forwarder = docIdForwarder.apply(doc); matcherSink.matchQuery(queryId, entry.getMatchQuery(), entry.getMetadata(), forwarder); } - private QCEVisitor getEntry(VersionedQueryCacheEntry versionedEntry, MonitorDataValues dataValues) - throws IOException { - if (versionedEntry.version != dataValues.getVersion()) { - // The cache is more up-to-date than the index associated with this collector. - // For consistency, we parse the query from the earlier index state. - return QCEVisitor.getComponent( - queryDecoder.decode(dataValues), - monitorQueryCache.getDecomposer(), - dataValues.getCacheId()); - } - return versionedEntry.entry; + private QCEVisitor getEntry(MonitorDataValues dataValues) throws IOException { + var versionedEntry = + monitorQueryCache == null + ? null + : monitorQueryCache.computeIfStale(dataValues, queryDecoder); + return (versionedEntry == null || versionedEntry.version != dataValues.getVersion()) + ? QCEVisitor.getComponent( + queryDecoder.decode(dataValues), + MonitorConstants.QUERY_DECOMPOSER, + dataValues.getCacheId()) + : versionedEntry.entry; } private void superCollect(int doc) throws IOException { @@ -90,7 +89,7 @@ public ScoreMode scoreMode() { @Override public void complete() throws IOException { - super.complete(); + super.finish(); matcherSink.complete(); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java index 8cbadd0316b9..37eb9b8a0979 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java @@ -40,12 +40,12 @@ import org.apache.lucene.monitor.MonitorQuery; import org.apache.lucene.monitor.Presearcher; import org.apache.lucene.monitor.QCEVisitor; -import org.apache.lucene.monitor.QueryDecomposer; import org.apache.lucene.util.BytesRef; import org.apache.solr.common.SolrException; import org.apache.solr.common.SolrInputDocument; import org.apache.solr.common.util.JavaBinCodec; import org.apache.solr.core.SolrCore; +import org.apache.solr.monitor.MonitorConstants; import org.apache.solr.monitor.MonitorSchemaFields; import org.apache.solr.monitor.SimpleQueryParser; import org.apache.solr.schema.IndexSchema; @@ -61,7 +61,6 @@ public class MonitorUpdateRequestProcessor extends UpdateRequestProcessor { private final IndexSchema indexSchema; private final Presearcher presearcher; private final MonitorSchemaFields monitorSchemaFields; - private final QueryDecomposer decomposer = new QueryDecomposer(); public MonitorUpdateRequestProcessor( UpdateRequestProcessor next, @@ -144,7 +143,7 @@ private void copyFirstChildToParent(SolrInputDocument parent, SolrInputDocument } private Stream decompose(MonitorQuery monitorQuery, String payload) { - return QCEVisitor.decompose(monitorQuery, decomposer).stream() + return QCEVisitor.decompose(monitorQuery, MonitorConstants.QUERY_DECOMPOSER).stream() .map( qce -> { Document doc = diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml new file mode 100644 index 000000000000..dabf463a2423 --- /dev/null +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml @@ -0,0 +1,185 @@ + + + + + 9.4 + + ${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 + 10 + id + + + reverseSearch + + + + + explicit + json + true + id + + + + + explicit + + + + + 0 + false + xml + _version_ + + + + + 0 + /pingQuery + + + all + + + + + + text_general + + + + + true + + + tvComponent + + + + + + true + false + + + terms + tvComponent + + + + string + + + + + explicit + + + elevator + + + + + + + + TermFilteredPresearcher + + + + + text/plain; charset=UTF-8 + + + ${velocity.template.base.dir:} + ${velocity.solr.resource.loader.enabled:true} + ${velocity.params.resource.loader.enabled:false} + + + + + diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java index 6a2322a685b3..a9b6e8135124 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java @@ -167,7 +167,6 @@ public void testNoDocListInResponse() throws Exception { } @Test - @ShardsFixed(num = 1) public void testDefaultParser() throws Exception { del("*:*"); index(id, Integer.toString(0), "_mq", "content_s:\"elevator stairs\""); @@ -198,7 +197,7 @@ public void testDefaultParser() throws Exception { } @Test - @ShardsFixed(num = 1) + @ShardsFixed(num = 2) public void testDisjunctionQuery() throws Exception { del("*:*"); index( @@ -239,7 +238,6 @@ public void testDisjunctionQuery() throws Exception { } @Test - @ShardsFixed(num = 1) public void testNoDanglingDecomposition() throws Exception { del("*:*"); index( @@ -288,7 +286,6 @@ public void testNoDanglingDecomposition() throws Exception { } @Test - @ShardsFixed(num = 1) public void testNotQuery() throws Exception { del("*:*"); index(id, Integer.toString(0), "_mq", "*:* -content0_s:\"elevator stairs\""); @@ -318,7 +315,6 @@ public void testNotQuery() throws Exception { } @Test - @ShardsFixed(num = 1) public void testWildCardQuery() throws Exception { del("*:*"); index(id, Integer.toString(0), "_mq", "content_s:te*"); @@ -355,7 +351,6 @@ public void testWildCardQuery() throws Exception { } @Test - @ShardsFixed(num = 1) public void manySegmentsQuery() throws Exception { del("*:*"); int count = 10_000; @@ -526,7 +521,6 @@ public void testMultiDocHighlightMatchType() throws Exception { } @Test - @ShardsFixed(num = 1) public void testHighlightMatchType() throws Exception { del("*:*"); index(id, Integer.toString(0), "_mq", "content0_s:\"elevator stairs\""); diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/NoCacheMonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/NoCacheMonitorSolrQueryTest.java new file mode 100644 index 000000000000..9e734553f8e7 --- /dev/null +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/NoCacheMonitorSolrQueryTest.java @@ -0,0 +1,30 @@ +/* + * + * * 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.monitor; + +import org.junit.BeforeClass; + +public class NoCacheMonitorSolrQueryTest extends MonitorSolrQueryTest { + + @BeforeClass + public static void beforeSuperClass() { + configString = "solrconfig-no-cache.xml"; + } +} diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java index b60ae9bcb4c4..cbdfee6d06d7 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java @@ -30,7 +30,6 @@ public static void beforeSuperClass() { } @Test - @ShardsFixed(num = 1) public void indexBigQueryTest() throws Exception { del("*:*"); index( From 2362ce7ff553bfd1f9b88ca4a9150e39f50bdde1 Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Thu, 4 Apr 2024 18:43:55 -0400 Subject: [PATCH 10/85] move manySegmentsTest to ParallelMonitorSolrQueryTest --- .../solr/monitor/MonitorSolrQueryTest.java | 71 ----------------- .../monitor/ParallelMonitorSolrQueryTest.java | 79 +++++++++++++++++++ 2 files changed, 79 insertions(+), 71 deletions(-) diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java index a9b6e8135124..03d77bca6ca4 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java @@ -36,7 +36,6 @@ import java.util.LinkedHashMap; import java.util.List; import java.util.Map; -import java.util.stream.IntStream; import org.apache.lucene.monitor.HighlightsMatch; import org.apache.lucene.monitor.MonitorFields; import org.apache.solr.BaseDistributedSearchTestCase; @@ -350,76 +349,6 @@ public void testWildCardQuery() throws Exception { validate(response, 4, List.of("0", "1", "2")); } - @Test - public void manySegmentsQuery() throws Exception { - del("*:*"); - int count = 10_000; - IntStream.range(0, count) - .forEach( - i -> { - try { - index(id, Integer.toString(i), "_mq", "content_s:\"elevator stairs\""); - } catch (Exception e) { - throw new IllegalStateException(e); - } - }); - commit(); - handle.clear(); - handle.put("responseHeader", SKIP); - handle.put("response", SKIP); - - Object[] params = - new Object[] { - CommonParams.SORT, - id + " desc", - CommonParams.JSON, - read("/monitor/multi-doc-batch.json"), - REVERSE_SEARCH_PARAM_NAME, - true, - QUERY_MATCH_TYPE_KEY, - "simple" - }; - - QueryResponse response = query(params); - validate(response, 0, 0, "0"); - assertEquals(count, ((Map) response.getResponse().get("monitor")).get("queriesRun")); - assertEquals( - count, - ((List) - ((Map) - ((Map) - ((Map) response.getResponse().get("monitor")) - .get("monitorDocuments")) - .get(0)) - .get("queries")) - .size()); - - IntStream.range(count / 2, count) - .forEach( - i -> { - try { - index(id, Integer.toString(i), "_mq", "content_s:\"x y\""); - } catch (Exception e) { - throw new IllegalStateException(e); - } - }); - commit(); - - response = query(params); - validate(response, 0, 0, "0"); - assertEquals(count / 2, ((Map) response.getResponse().get("monitor")).get("queriesRun")); - assertEquals( - count / 2, - ((List) - ((Map) - ((Map) - ((Map) response.getResponse().get("monitor")) - .get("monitorDocuments")) - .get(0)) - .get("queries")) - .size()); - } - @Test @ShardsFixed(num = 2) public void testDefaultQueryMatchTypeIsNone() throws Exception { diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java index 20352989bed0..5b8848ffebb8 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java @@ -19,7 +19,16 @@ package org.apache.solr.monitor; +import static org.apache.solr.monitor.MonitorConstants.QUERY_MATCH_TYPE_KEY; +import static org.apache.solr.monitor.MonitorConstants.REVERSE_SEARCH_PARAM_NAME; + +import java.util.List; +import java.util.Map; +import java.util.stream.IntStream; +import org.apache.solr.client.solrj.response.QueryResponse; +import org.apache.solr.common.params.CommonParams; import org.junit.BeforeClass; +import org.junit.Test; public class ParallelMonitorSolrQueryTest extends MonitorSolrQueryTest { @@ -32,4 +41,74 @@ public static void beforeSuperClass() { protected boolean supportsWriteToDocList() { return false; } + + @Test + public void manySegmentsQuery() throws Exception { + del("*:*"); + int count = 10_000; + IntStream.range(0, count) + .forEach( + i -> { + try { + index(id, Integer.toString(i), "_mq", "content_s:\"elevator stairs\""); + } catch (Exception e) { + throw new IllegalStateException(e); + } + }); + commit(); + handle.clear(); + handle.put("responseHeader", SKIP); + handle.put("response", SKIP); + + Object[] params = + new Object[] { + CommonParams.SORT, + id + " desc", + CommonParams.JSON, + read("/monitor/multi-doc-batch.json"), + REVERSE_SEARCH_PARAM_NAME, + true, + QUERY_MATCH_TYPE_KEY, + "simple" + }; + + QueryResponse response = query(params); + validate(response, 0, 0, "0"); + assertEquals(count, ((Map) response.getResponse().get("monitor")).get("queriesRun")); + assertEquals( + count, + ((List) + ((Map) + ((Map) + ((Map) response.getResponse().get("monitor")) + .get("monitorDocuments")) + .get(0)) + .get("queries")) + .size()); + + IntStream.range(count / 2, count) + .forEach( + i -> { + try { + index(id, Integer.toString(i), "_mq", "content_s:\"x y\""); + } catch (Exception e) { + throw new IllegalStateException(e); + } + }); + commit(); + + response = query(params); + validate(response, 0, 0, "0"); + assertEquals(count / 2, ((Map) response.getResponse().get("monitor")).get("queriesRun")); + assertEquals( + count / 2, + ((List) + ((Map) + ((Map) + ((Map) response.getResponse().get("monitor")) + .get("monitorDocuments")) + .get(0)) + .get("queries")) + .size()); + } } From e5a1382ac277025711a2c8b7ee649e899d0d7ea3 Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Fri, 5 Apr 2024 16:15:58 -0400 Subject: [PATCH 11/85] call CandidateMatcher directly --- .../lucene/monitor/CandidateMatcher.java | 134 ++++++++++++++++++ .../monitor/CollectingMatcherProxy.java | 67 --------- .../lucene/monitor/HighlightMatcherProxy.java | 83 ----------- .../apache/lucene/monitor/MatcherProxy.java | 36 ----- .../lucene/monitor/MatchesAggregator.java | 27 ++-- .../lucene/monitor/MonitorDataValues.java | 84 ----------- .../lucene/monitor/SimpleMatcherProxy.java | 43 ------ .../solr/monitor/SolrMonitorQueryDecoder.java | 1 - .../solr/monitor/cache/MonitorQueryCache.java | 2 +- .../monitor/cache/SharedMonitorCache.java | 2 +- .../SharedMonitorCacheLatestRegenerator.java | 2 +- .../search/ParallelSolrMatcherSink.java | 29 ++-- .../solr/monitor/search/SolrMatcherSink.java | 7 +- .../search/SolrMatcherSinkFactory.java | 19 +-- .../search/SolrMonitorQueryCollector.java | 15 +- .../monitor/search/SyncSolrMatcherSink.java | 24 ++-- .../monitor/search/UncheckRunnable.java} | 22 ++- 17 files changed, 209 insertions(+), 388 deletions(-) create mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/CandidateMatcher.java delete mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/CollectingMatcherProxy.java delete mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/HighlightMatcherProxy.java delete mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/MatcherProxy.java delete mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorDataValues.java delete mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/SimpleMatcherProxy.java rename solr/modules/monitor/src/java/org/apache/{lucene/monitor/SingleMatchConsumer.java => solr/monitor/search/UncheckRunnable.java} (62%) diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/CandidateMatcher.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/CandidateMatcher.java new file mode 100644 index 000000000000..e204d849b549 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/CandidateMatcher.java @@ -0,0 +1,134 @@ +/* + * 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 java.util.function.BiConsumer; +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 BiConsumer matchConsumer; + + 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) { + if (matchConsumer != null) { + matchConsumer.accept(match, 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 */ + void reportError(String queryId, Exception e) { + this.errors.put(queryId, e); + } + + public void setMatchConsumer(BiConsumer matchConsumer) { + this.matchConsumer = matchConsumer; + } + + /** + * @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/monitor/src/java/org/apache/lucene/monitor/CollectingMatcherProxy.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/CollectingMatcherProxy.java deleted file mode 100644 index ea1a29b23418..000000000000 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/CollectingMatcherProxy.java +++ /dev/null @@ -1,67 +0,0 @@ -/* - * - * * 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.Map; -import org.apache.lucene.search.IndexSearcher; -import org.apache.lucene.search.Query; -import org.apache.lucene.search.ScoreMode; - -public abstract class CollectingMatcherProxy extends CollectingMatcher - implements MatcherProxy { - - private SingleMatchConsumer singleMatchConsumer; - private MultiMatchingQueries cachedResult; - - public CollectingMatcherProxy(IndexSearcher searcher, ScoreMode scoreMode) { - super(searcher, scoreMode); - } - - @Override - public void matchQuery(String queryId, Query matchQuery, Map metadata) { - try { - super.matchQuery(queryId, matchQuery, metadata); - } catch (Exception e) { - super.reportError(queryId, e); - } - } - - @Override - public MultiMatchingQueries finish(int queryCount) { - cachedResult = super.finish(Long.MIN_VALUE, queryCount); - return cachedResult; - } - - protected void consumeMatch(String queryId, int batchDocId) throws IOException { - if (singleMatchConsumer != null) { - singleMatchConsumer.accept(queryId, batchDocId); - } - } - - @Override - public void setNextMatchConsumer(SingleMatchConsumer singleMatchConsumer) { - this.singleMatchConsumer = singleMatchConsumer; - } - - @Override - public MultiMatchingQueries matches() { - return cachedResult; - } -} diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/HighlightMatcherProxy.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/HighlightMatcherProxy.java deleted file mode 100644 index 6d2eebe5eb27..000000000000 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/HighlightMatcherProxy.java +++ /dev/null @@ -1,83 +0,0 @@ -/* - * - * * 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 org.apache.lucene.search.IndexSearcher; -import org.apache.lucene.search.Query; - -public class HighlightMatcherProxy implements MatcherProxy { - - private final List> multiMatchingQueries = - new ArrayList<>(); - private final IndexSearcher indexSearcher; - private final CandidateMatcher resolverMatcher; - private SingleMatchConsumer singleMatchConsumer; - private MultiMatchingQueries cachedResult; - - public HighlightMatcherProxy(IndexSearcher indexSearcher) { - this.indexSearcher = indexSearcher; - this.resolverMatcher = HighlightsMatch.MATCHER.createMatcher(indexSearcher); - } - - @Override - public void matchQuery(String queryId, Query matchQuery, Map metadata) { - try { - var highlightMatcher = HighlightsMatch.MATCHER.createMatcher(indexSearcher); - highlightMatcher.matchQuery(queryId, matchQuery, metadata); - var matchingQueries = highlightMatcher.finish(0, 0); - this.multiMatchingQueries.add(matchingQueries); - if (singleMatchConsumer != null) { - for (int i = 0; i < matchingQueries.getBatchSize(); i++) { - if (!matchingQueries.getMatches(i).isEmpty()) { - singleMatchConsumer.accept(queryId, i); - } - } - } - } catch (IOException e) { - throw new IllegalStateException("This should be impossible for an in-memory searcher", e); - } - } - - @Override - public MultiMatchingQueries finish(int queryCount) { - cachedResult = - MatchesAggregator.aggregate(multiMatchingQueries, indexSearcher, this::resolve, queryCount); - return cachedResult; - } - - @Override - public void setNextMatchConsumer(SingleMatchConsumer singleMatchConsumer) { - this.singleMatchConsumer = singleMatchConsumer; - } - - @Override - public MultiMatchingQueries matches() { - return cachedResult; - } - - @Override - public HighlightsMatch resolve(HighlightsMatch match1, HighlightsMatch match2) { - return resolverMatcher.resolve(match1, match2); - } -} diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatcherProxy.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatcherProxy.java deleted file mode 100644 index 289e8df5d5dd..000000000000 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatcherProxy.java +++ /dev/null @@ -1,36 +0,0 @@ -/* - * - * * 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.util.Map; -import org.apache.lucene.search.Query; - -public interface MatcherProxy { - - void matchQuery(String queryId, Query matchQuery, Map metadata); - - MultiMatchingQueries finish(int queryCount); - - void setNextMatchConsumer(SingleMatchConsumer singleMatchConsumer); - - MultiMatchingQueries matches(); - - T resolve(T match1, T match2); -} diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatchesAggregator.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatchesAggregator.java index b05698168694..9adde58d7e0b 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatchesAggregator.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatchesAggregator.java @@ -20,21 +20,18 @@ import java.util.List; import java.util.Map; -import java.util.function.BiFunction; -import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; public class MatchesAggregator extends CandidateMatcher { - private final BiFunction resolver; + private final CandidateMatcher resolvingMatcher; private MatchesAggregator( - List> multiMatches, - IndexSearcher searcher, - BiFunction resolver) { - super(searcher); - this.resolver = resolver; - for (var matches : multiMatches) { + List> matchers, CandidateMatcher resolvingMatcher) { + super(resolvingMatcher.searcher); + this.resolvingMatcher = resolvingMatcher; + for (var matcher : matchers) { + var matches = matcher.finish(Long.MIN_VALUE, -1); for (int doc = 0; doc < matches.getBatchSize(); doc++) { for (T match : matches.getMatches(doc)) { this.addMatch(match, doc); @@ -47,21 +44,17 @@ private MatchesAggregator( } @Override - protected void matchQuery(String queryId, Query matchQuery, Map metadata) { + public void matchQuery(String queryId, Query matchQuery, Map metadata) { throw new UnsupportedOperationException("only use for aggregating other matchers"); } @Override public T resolve(T match1, T match2) { - return resolver.apply(match1, match2); + return resolvingMatcher.resolve(match1, match2); } public static MultiMatchingQueries aggregate( - List> matchingQueries, - IndexSearcher searcher, - BiFunction resolver, - int queryCount) { - return new MatchesAggregator<>(matchingQueries, searcher, resolver) - .finish(Long.MIN_VALUE, queryCount); + List> matchers, CandidateMatcher resolver, int queryCount) { + return new MatchesAggregator<>(matchers, resolver).finish(Long.MIN_VALUE, queryCount); } } diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorDataValues.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorDataValues.java deleted file mode 100644 index fe568dda34ee..000000000000 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorDataValues.java +++ /dev/null @@ -1,84 +0,0 @@ -/* - * - * * 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 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.search.DocIdSetIterator; - -public class MonitorDataValues { - - private SortedDocValues queryIdIt; - private SortedDocValues cacheIdIt; - private SortedDocValues mqIt; - private SortedDocValues payloadIt; - private NumericDocValues versionIt; - private int currentDoc = DocIdSetIterator.NO_MORE_DOCS; - private LeafReader reader; - - public void update(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); - payloadIt = reader.getSortedDocValues(MonitorFields.PAYLOAD); - versionIt = reader.getNumericDocValues(MonitorFields.VERSION); - currentDoc = DocIdSetIterator.NO_MORE_DOCS; - } - - public void advanceTo(int doc) { - currentDoc = doc; - } - - public String getQueryId() throws IOException { - queryIdIt.advanceExact(currentDoc); - return queryIdIt.lookupOrd(queryIdIt.ordValue()).utf8ToString(); - } - - public String getCacheId() throws IOException { - cacheIdIt.advanceExact(currentDoc); - 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 String getPayload() throws IOException { - if (payloadIt != null) { - if (payloadIt.advanceExact(currentDoc)) { - return payloadIt.lookupOrd(payloadIt.ordValue()).utf8ToString(); - } - return null; - } - return reader.document(currentDoc).get(MonitorFields.PAYLOAD); - } - - public long getVersion() throws IOException { - versionIt.advanceExact(currentDoc); - return versionIt.longValue(); - } -} diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/SimpleMatcherProxy.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/SimpleMatcherProxy.java deleted file mode 100644 index cdfd36a3677d..000000000000 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/SimpleMatcherProxy.java +++ /dev/null @@ -1,43 +0,0 @@ -/* - * - * * 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 org.apache.lucene.search.IndexSearcher; -import org.apache.lucene.search.Scorable; -import org.apache.lucene.search.ScoreMode; - -public class SimpleMatcherProxy extends CollectingMatcherProxy { - - public SimpleMatcherProxy(IndexSearcher searcher, ScoreMode scoreMode) { - super(searcher, scoreMode); - } - - @Override - public QueryMatch resolve(QueryMatch match1, QueryMatch match2) { - return match1; - } - - @Override - protected QueryMatch doMatch(String queryId, int doc, Scorable scorer) throws IOException { - super.consumeMatch(queryId, doc); - return new QueryMatch(queryId); - } -} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java index 1a26f61cddec..4e1045391c0c 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java @@ -21,7 +21,6 @@ import java.io.IOException; import java.util.Map; -import org.apache.lucene.monitor.MonitorDataValues; import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.monitor.MonitorQuery; import org.apache.solr.core.SolrCore; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java index ac6d97f3ac7b..a35f25632126 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java @@ -20,8 +20,8 @@ package org.apache.solr.monitor.cache; import java.io.IOException; -import org.apache.lucene.monitor.MonitorDataValues; import org.apache.lucene.util.BytesRef; +import org.apache.solr.monitor.MonitorDataValues; import org.apache.solr.monitor.SolrMonitorQueryDecoder; public interface MonitorQueryCache { diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java index bb5a00546d4b..612c9c589c51 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java @@ -30,7 +30,6 @@ import java.util.Map; import java.util.concurrent.atomic.AtomicReference; import java.util.function.BiPredicate; -import org.apache.lucene.monitor.MonitorDataValues; import org.apache.lucene.monitor.MonitorQuery; import org.apache.lucene.monitor.QCEVisitor; import org.apache.lucene.monitor.QueryTermFilterVisitor; @@ -40,6 +39,7 @@ import org.apache.solr.metrics.MetricsMap; import org.apache.solr.metrics.SolrMetricsContext; import org.apache.solr.monitor.MonitorConstants; +import org.apache.solr.monitor.MonitorDataValues; import org.apache.solr.monitor.SolrMonitorQueryDecoder; import org.apache.solr.search.CacheRegenerator; import org.apache.solr.search.SolrCache; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java index 74775bda44ed..a29196ce0a88 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java @@ -22,10 +22,10 @@ import java.io.IOException; import org.apache.lucene.document.LongPoint; import org.apache.lucene.index.LeafReaderContext; -import org.apache.lucene.monitor.MonitorDataValues; import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; +import org.apache.solr.monitor.MonitorDataValues; import org.apache.solr.monitor.SolrMonitorQueryDecoder; import org.apache.solr.search.CacheRegenerator; import org.apache.solr.search.SolrCache; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java index 913cf398cb7a..f9f81e364e08 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java @@ -27,32 +27,30 @@ import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorCompletionService; import java.util.concurrent.ExecutorService; -import java.util.function.BiFunction; import java.util.function.Consumer; import java.util.function.Function; -import org.apache.lucene.monitor.MatcherProxy; +import org.apache.lucene.monitor.CandidateMatcher; import org.apache.lucene.monitor.MatchesAggregator; import org.apache.lucene.monitor.MultiMatchingQueries; import org.apache.lucene.monitor.QueryMatch; -import org.apache.lucene.monitor.SingleMatchConsumer; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; class ParallelSolrMatcherSink implements SolrMatcherSink { - private final CompletionService> completionService; - private final Function> matcherProxyFactory; + private final CompletionService> completionService; + private final Function> matcherFactory; private final IndexSearcher docBatchSearcher; private final Consumer> queriesConsumer; private int tasksLeft; public ParallelSolrMatcherSink( ExecutorService executor, - Function> matcherProxyFactory, + Function> matcherFactory, IndexSearcher docBatchSearcher, Consumer> queriesConsumer) { this.completionService = new ExecutorCompletionService<>(executor); - this.matcherProxyFactory = matcherProxyFactory; + this.matcherFactory = matcherFactory; this.docBatchSearcher = docBatchSearcher; this.queriesConsumer = queriesConsumer; } @@ -62,20 +60,19 @@ public void matchQuery( String queryId, Query matchQuery, Map metadata, - SingleMatchConsumer matchConsumer) { + Runnable singleMatchConsumer) { completionService.submit( () -> { - var matcherProxy = matcherProxyFactory.apply(docBatchSearcher); - matcherProxy.matchQuery(queryId, matchQuery, metadata); - matcherProxy.finish(1); - return matcherProxy.matches(); + var matcher = matcherFactory.apply(docBatchSearcher); + matcher.matchQuery(queryId, matchQuery, metadata); + return matcher; }); tasksLeft++; } @Override public void complete() throws IOException { - List> matchingQueries = new ArrayList<>(); + List> matchingQueries = new ArrayList<>(); int queryCount = tasksLeft; while (tasksLeft-- > 0) { try { @@ -85,12 +82,12 @@ public void complete() throws IOException { throw new IOException(e); } catch (ExecutionException e) { throw new IllegalStateException( - MatcherProxy.class.getSimpleName() + " should never throw an exception", e); + CandidateMatcher.class.getSimpleName() + " should never throw an exception", e); } } - BiFunction resolver = matcherProxyFactory.apply(docBatchSearcher)::resolve; + var resolvingMatcher = matcherFactory.apply(docBatchSearcher); var aggregateMatches = - MatchesAggregator.aggregate(matchingQueries, docBatchSearcher, resolver, queryCount); + MatchesAggregator.aggregate(matchingQueries, resolvingMatcher, queryCount); queriesConsumer.accept(aggregateMatches); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java index c3dc5f72e038..da450253194f 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java @@ -21,16 +21,13 @@ import java.io.IOException; import java.util.Map; -import org.apache.lucene.monitor.SingleMatchConsumer; import org.apache.lucene.search.Query; interface SolrMatcherSink { void matchQuery( - String queryId, - Query matchQuery, - Map metadata, - SingleMatchConsumer singleMatchConsumer); + String queryId, Query matchQuery, Map metadata, Runnable singleMatchConsumer) + throws IOException; void complete() throws IOException; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java index dc231e3dc17a..995fe2d69f2b 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java @@ -23,14 +23,12 @@ import java.util.concurrent.ExecutorService; import java.util.function.Consumer; import java.util.function.Function; +import org.apache.lucene.monitor.CandidateMatcher; import org.apache.lucene.monitor.DocumentBatchVisitor; -import org.apache.lucene.monitor.HighlightMatcherProxy; -import org.apache.lucene.monitor.MatcherProxy; +import org.apache.lucene.monitor.HighlightsMatch; import org.apache.lucene.monitor.MultiMatchingQueries; import org.apache.lucene.monitor.QueryMatch; -import org.apache.lucene.monitor.SimpleMatcherProxy; import org.apache.lucene.search.IndexSearcher; -import org.apache.lucene.search.ScoreMode; class SolrMatcherSinkFactory { @@ -57,7 +55,7 @@ SolrMatcherSink build( } else if (matchType == QueryMatchType.HIGHLIGHTS) { return build( documentBatch, - HighlightMatcherProxy::new, + HighlightsMatch.MATCHER::createMatcher, matchingQueries -> QueryMatchResponseCodec.highlightEncode( matchingQueries, monitorResult, documentBatch.size())); @@ -67,22 +65,19 @@ SolrMatcherSink build( private SolrMatcherSink buildSimple( DocumentBatchVisitor documentBatch, Consumer> encoder) { - return build( - documentBatch, - searcher -> new SimpleMatcherProxy(searcher, ScoreMode.COMPLETE_NO_SCORES), - encoder); + return build(documentBatch, QueryMatch.SIMPLE_MATCHER::createMatcher, encoder); } private SolrMatcherSink build( DocumentBatchVisitor documentBatch, - Function> matcherProxyFactory, + Function> matcherFactory, Consumer> encoder) { var docBatchSearcher = new IndexSearcher(documentBatch.get()); if (executorService == null) { - return new SyncSolrMatcherSink<>(matcherProxyFactory.apply(docBatchSearcher), encoder); + return new SyncSolrMatcherSink<>(matcherFactory.apply(docBatchSearcher), encoder); } else { return new ParallelSolrMatcherSink<>( - executorService, matcherProxyFactory, docBatchSearcher, encoder); + executorService, matcherFactory, docBatchSearcher, encoder); } } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java index da7626f2826d..0c4a92673929 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java @@ -22,11 +22,10 @@ import java.io.IOException; import java.util.function.Function; import org.apache.lucene.index.LeafReaderContext; -import org.apache.lucene.monitor.MonitorDataValues; import org.apache.lucene.monitor.QCEVisitor; -import org.apache.lucene.monitor.SingleMatchConsumer; import org.apache.lucene.search.ScoreMode; import org.apache.solr.monitor.MonitorConstants; +import org.apache.solr.monitor.MonitorDataValues; import org.apache.solr.monitor.SolrMonitorQueryDecoder; import org.apache.solr.monitor.cache.MonitorQueryCache; import org.apache.solr.search.DelegatingCollector; @@ -37,7 +36,7 @@ class SolrMonitorQueryCollector extends DelegatingCollector { private final SolrMonitorQueryDecoder queryDecoder; private final SolrMatcherSink matcherSink; private final MonitorDataValues dataValues = new MonitorDataValues(); - private final Function docIdForwarder; + private final Function docIdForwarder; SolrMonitorQueryCollector(CollectorContext collectorContext) { this.monitorQueryCache = collectorContext.queryCache; @@ -56,7 +55,11 @@ public void collect(int doc) throws IOException { var entry = getEntry(dataValues); var queryId = dataValues.getQueryId(); var forwarder = docIdForwarder.apply(doc); - matcherSink.matchQuery(queryId, entry.getMatchQuery(), entry.getMetadata(), forwarder); + matcherSink.matchQuery( + queryId, + entry.getMatchQuery(), + entry.getMetadata(), + forwarder == null ? null : UncheckRunnable.ioUncheckButThrow(forwarder)); } private QCEVisitor getEntry(MonitorDataValues dataValues) throws IOException { @@ -112,7 +115,7 @@ static class CollectorContext { } } - private class MatchingDocForwarder implements SingleMatchConsumer { + private class MatchingDocForwarder implements UncheckRunnable { private final int doc; private boolean visited; @@ -122,7 +125,7 @@ private MatchingDocForwarder(int doc) { } @Override - public void accept(String __, int ___) throws IOException { + public void run() throws IOException { if (!visited) { superCollect(doc); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java index 1b9b14a8a28a..092ff6b26090 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java @@ -19,40 +19,40 @@ package org.apache.solr.monitor.search; +import java.io.IOException; import java.util.Map; import java.util.function.Consumer; -import org.apache.lucene.monitor.MatcherProxy; +import org.apache.lucene.monitor.CandidateMatcher; import org.apache.lucene.monitor.MultiMatchingQueries; import org.apache.lucene.monitor.QueryMatch; -import org.apache.lucene.monitor.SingleMatchConsumer; import org.apache.lucene.search.Query; class SyncSolrMatcherSink implements SolrMatcherSink { - private final MatcherProxy matcherProxy; + private final CandidateMatcher matcher; private final Consumer> queriesConsumer; private int queryCount; SyncSolrMatcherSink( - MatcherProxy matcherProxy, Consumer> queriesConsumer) { - this.matcherProxy = matcherProxy; + CandidateMatcher matcher, Consumer> queriesConsumer) { + this.matcher = matcher; this.queriesConsumer = queriesConsumer; } @Override public void matchQuery( - String queryId, - Query matchQuery, - Map metadata, - SingleMatchConsumer singleMatchConsumer) { + String queryId, Query matchQuery, Map metadata, Runnable singleMatchConsumer) + throws IOException { queryCount++; - matcherProxy.setNextMatchConsumer(singleMatchConsumer); - matcherProxy.matchQuery(queryId, matchQuery, metadata); + if (singleMatchConsumer != null) { + matcher.setMatchConsumer((__, ___) -> singleMatchConsumer.run()); + } + matcher.matchQuery(queryId, matchQuery, metadata); } @Override public void complete() { - queriesConsumer.accept(matcherProxy.finish(queryCount)); + queriesConsumer.accept(matcher.finish(Long.MIN_VALUE, queryCount)); } @Override diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/SingleMatchConsumer.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/UncheckRunnable.java similarity index 62% rename from solr/modules/monitor/src/java/org/apache/lucene/monitor/SingleMatchConsumer.java rename to solr/modules/monitor/src/java/org/apache/solr/monitor/search/UncheckRunnable.java index a634cb6cbbf1..a58c25c9722d 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/SingleMatchConsumer.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/UncheckRunnable.java @@ -17,11 +17,27 @@ * */ -package org.apache.lucene.monitor; +package org.apache.solr.monitor.search; import java.io.IOException; -public interface SingleMatchConsumer { +@FunctionalInterface +public interface UncheckRunnable { - void accept(String queryId, int batchDocId) throws IOException; + void run() throws E; + + static Runnable ioUncheckButThrow(UncheckRunnable function) { + return () -> { + try { + function.run(); + } catch (Throwable exception) { + throwAsUnchecked(exception); + } + }; + } + + @SuppressWarnings("unchecked") + private static void throwAsUnchecked(Throwable throwable) throws E { + throw (E) throwable; + } } From b7b58b3ef2239b9d7608cb575cf0f29d90395661 Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Sat, 6 Apr 2024 00:56:10 -0400 Subject: [PATCH 12/85] remove doc forwarding callback --- .../lucene/monitor/CandidateMatcher.java | 9 ---- .../search/ParallelSolrMatcherSink.java | 7 +-- .../solr/monitor/search/SolrMatcherSink.java | 3 +- .../search/SolrMatcherSinkFactory.java | 2 +- .../search/SolrMonitorQueryCollector.java | 41 +++--------------- .../monitor/search/SyncSolrMatcherSink.java | 35 +++++++++++---- .../solr/monitor/search/UncheckRunnable.java | 43 ------------------- 7 files changed, 36 insertions(+), 104 deletions(-) delete mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/UncheckRunnable.java diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/CandidateMatcher.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/CandidateMatcher.java index e204d849b549..9bd920bbdbd0 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/CandidateMatcher.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/CandidateMatcher.java @@ -23,7 +23,6 @@ import java.util.List; import java.util.Map; import java.util.concurrent.TimeUnit; -import java.util.function.BiConsumer; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; @@ -37,7 +36,6 @@ public abstract class CandidateMatcher { private final List> matches; private long searchTime = System.nanoTime(); - private BiConsumer matchConsumer; private static class MatchHolder { Map matches = new HashMap<>(); @@ -75,9 +73,6 @@ public abstract void matchQuery(String queryId, Query matchQuery, Map docMatches = matches.get(doc); docMatches.matches.compute( match.getQueryId(), @@ -104,10 +99,6 @@ void reportError(String queryId, Exception e) { this.errors.put(queryId, e); } - public void setMatchConsumer(BiConsumer matchConsumer) { - this.matchConsumer = matchConsumer; - } - /** * @return the matches from this matcher */ diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java index f9f81e364e08..dee972ebf50a 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java @@ -56,11 +56,7 @@ public ParallelSolrMatcherSink( } @Override - public void matchQuery( - String queryId, - Query matchQuery, - Map metadata, - Runnable singleMatchConsumer) { + public boolean matchQuery(String queryId, Query matchQuery, Map metadata) { completionService.submit( () -> { var matcher = matcherFactory.apply(docBatchSearcher); @@ -68,6 +64,7 @@ public void matchQuery( return matcher; }); tasksLeft++; + return false; } @Override diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java index da450253194f..2e23a4795282 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java @@ -25,8 +25,7 @@ interface SolrMatcherSink { - void matchQuery( - String queryId, Query matchQuery, Map metadata, Runnable singleMatchConsumer) + boolean matchQuery(String queryId, Query matchQuery, Map metadata) throws IOException; void complete() throws IOException; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java index 995fe2d69f2b..af6a28bfdc42 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java @@ -74,7 +74,7 @@ private SolrMatcherSink build( Consumer> encoder) { var docBatchSearcher = new IndexSearcher(documentBatch.get()); if (executorService == null) { - return new SyncSolrMatcherSink<>(matcherFactory.apply(docBatchSearcher), encoder); + return new SyncSolrMatcherSink<>(matcherFactory, docBatchSearcher, encoder); } else { return new ParallelSolrMatcherSink<>( executorService, matcherFactory, docBatchSearcher, encoder); diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java index 0c4a92673929..b111ccbfd460 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java @@ -20,7 +20,6 @@ package org.apache.solr.monitor.search; import java.io.IOException; -import java.util.function.Function; import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.monitor.QCEVisitor; import org.apache.lucene.search.ScoreMode; @@ -36,17 +35,13 @@ class SolrMonitorQueryCollector extends DelegatingCollector { private final SolrMonitorQueryDecoder queryDecoder; private final SolrMatcherSink matcherSink; private final MonitorDataValues dataValues = new MonitorDataValues(); - private final Function docIdForwarder; + private final boolean writeToDocList; SolrMonitorQueryCollector(CollectorContext collectorContext) { this.monitorQueryCache = collectorContext.queryCache; this.queryDecoder = collectorContext.queryDecoder; this.matcherSink = collectorContext.solrMatcherSink; - if (collectorContext.writeToDocList) { - this.docIdForwarder = MatchingDocForwarder::new; - } else { - this.docIdForwarder = __ -> null; - } + this.writeToDocList = collectorContext.writeToDocList; } @Override @@ -54,12 +49,10 @@ public void collect(int doc) throws IOException { dataValues.advanceTo(doc); var entry = getEntry(dataValues); var queryId = dataValues.getQueryId(); - var forwarder = docIdForwarder.apply(doc); - matcherSink.matchQuery( - queryId, - entry.getMatchQuery(), - entry.getMetadata(), - forwarder == null ? null : UncheckRunnable.ioUncheckButThrow(forwarder)); + boolean isMatch = matcherSink.matchQuery(queryId, entry.getMatchQuery(), entry.getMetadata()); + if (isMatch && writeToDocList) { + super.collect(doc); + } } private QCEVisitor getEntry(MonitorDataValues dataValues) throws IOException { @@ -75,10 +68,6 @@ private QCEVisitor getEntry(MonitorDataValues dataValues) throws IOException { : versionedEntry.entry; } - private void superCollect(int doc) throws IOException { - super.collect(doc); - } - @Override public void doSetNextReader(LeafReaderContext context) throws IOException { super.doSetNextReader(context); @@ -114,22 +103,4 @@ static class CollectorContext { this.writeToDocList = writeToDocList; } } - - private class MatchingDocForwarder implements UncheckRunnable { - - private final int doc; - private boolean visited; - - private MatchingDocForwarder(int doc) { - this.doc = doc; - } - - @Override - public void run() throws IOException { - if (!visited) { - superCollect(doc); - } - visited = true; - } - } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java index 092ff6b26090..835990990afe 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java @@ -20,39 +20,56 @@ package org.apache.solr.monitor.search; import java.io.IOException; +import java.util.ArrayList; +import java.util.List; import java.util.Map; import java.util.function.Consumer; +import java.util.function.Function; import org.apache.lucene.monitor.CandidateMatcher; +import org.apache.lucene.monitor.MatchesAggregator; import org.apache.lucene.monitor.MultiMatchingQueries; import org.apache.lucene.monitor.QueryMatch; +import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; class SyncSolrMatcherSink implements SolrMatcherSink { - private final CandidateMatcher matcher; + private final Function> matcherFactory; + private final IndexSearcher docBatchSearcher; private final Consumer> queriesConsumer; + private final List> matchers = new ArrayList<>(); private int queryCount; SyncSolrMatcherSink( - CandidateMatcher matcher, Consumer> queriesConsumer) { - this.matcher = matcher; + Function> matcherFactory, + IndexSearcher docBatchSearcher, + Consumer> queriesConsumer) { + this.matcherFactory = matcherFactory; + this.docBatchSearcher = docBatchSearcher; this.queriesConsumer = queriesConsumer; } @Override - public void matchQuery( - String queryId, Query matchQuery, Map metadata, Runnable singleMatchConsumer) + public boolean matchQuery(String queryId, Query matchQuery, Map metadata) throws IOException { queryCount++; - if (singleMatchConsumer != null) { - matcher.setMatchConsumer((__, ___) -> singleMatchConsumer.run()); - } + var matcher = matcherFactory.apply(docBatchSearcher); + matchers.add(matcher); 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 complete() { - queriesConsumer.accept(matcher.finish(Long.MIN_VALUE, queryCount)); + queriesConsumer.accept( + MatchesAggregator.aggregate(matchers, matcherFactory.apply(docBatchSearcher), queryCount)); } @Override diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/UncheckRunnable.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/UncheckRunnable.java deleted file mode 100644 index a58c25c9722d..000000000000 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/UncheckRunnable.java +++ /dev/null @@ -1,43 +0,0 @@ -/* - * - * * 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.monitor.search; - -import java.io.IOException; - -@FunctionalInterface -public interface UncheckRunnable { - - void run() throws E; - - static Runnable ioUncheckButThrow(UncheckRunnable function) { - return () -> { - try { - function.run(); - } catch (Throwable exception) { - throwAsUnchecked(exception); - } - }; - } - - @SuppressWarnings("unchecked") - private static void throwAsUnchecked(Throwable throwable) throws E { - throw (E) throwable; - } -} From ce40d60ad660efc78e32fb8aa4aa8301f016ca2d Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Tue, 9 Apr 2024 18:18:15 -0400 Subject: [PATCH 13/85] instantiate decoder in outer loop --- .../monitor/cache/SharedMonitorCacheLatestRegenerator.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java index a29196ce0a88..aa79f449b24c 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java @@ -56,12 +56,12 @@ public boolean regenerateItem( new IndexSearcher(searcher.getTopReaderContext()) .search(versionRangeQuery(cache), batchSize) .scoreDocs; - int batchesRemaining = cache.getInitialSize() / batchSize; + int batchesRemaining = cache.getInitialSize() / batchSize - 1; + SolrMonitorQueryDecoder decoder = SolrMonitorQueryDecoder.fromCore(searcher.getCore()); + MonitorDataValues dataValues = new MonitorDataValues(); while (topDocs.length > 0 && batchesRemaining > 0) { int docIndex = 0; - SolrMonitorQueryDecoder decoder = SolrMonitorQueryDecoder.fromCore(searcher.getCore()); for (LeafReaderContext ctx : reader.leaves()) { - MonitorDataValues dataValues = new MonitorDataValues(); dataValues.update(ctx); int shiftedMax = ctx.reader().maxDoc() + ctx.docBase; while (docIndex < topDocs.length From a2016766f1493559217155619ed541bdefc4e885 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 12 Apr 2024 17:15:00 -0400 Subject: [PATCH 14/85] ignore score for relevant match types --- .../solr/monitor/search/QueryMatchType.java | 10 ++++++++++ .../monitor/search/ReverseSearchComponent.java | 10 ++++++---- .../monitor/search/SolrMonitorQueryCollector.java | 15 +++++++++++++-- 3 files changed, 29 insertions(+), 6 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchType.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchType.java index aa89a79ef9b1..b4d8f6ac35c3 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchType.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchType.java @@ -24,6 +24,16 @@ public enum QueryMatchType { HIGHLIGHTS, NONE; + public final boolean needsScores; + + QueryMatchType() { + this(false); + } + + QueryMatchType(boolean needsScores) { + this.needsScores = needsScores; + } + static QueryMatchType fromString(String matchType) { if (SIMPLE.name().equalsIgnoreCase(matchType)) { return SIMPLE; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 85f34dc8ade3..99e2f5bc3f7c 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -38,6 +38,7 @@ import java.util.stream.Collectors; import org.apache.lucene.document.Document; import org.apache.lucene.monitor.DocumentBatchVisitor; +import org.apache.lucene.search.MatchAllDocsQuery; import org.apache.lucene.search.Query; import org.apache.lucene.util.NamedThreadFactory; import org.apache.solr.common.SolrException; @@ -89,8 +90,6 @@ public void prepare(ResponseBuilder rb) { req.getContext().put(DOCUMENT_BATCH_KEY, documentBatch); var writeToDocListRaw = req.getParams().get(WRITE_TO_DOC_LIST_KEY, "false"); boolean writeToDocList = Boolean.parseBoolean(writeToDocListRaw); - List mutableFilters = - Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); var matchType = QueryMatchType.fromString(req.getParams().get(QUERY_MATCH_TYPE_KEY)); Map monitorResult = new HashMap<>(); var matcherSink = solrMatcherSinkFactory.build(matchType, documentBatch, monitorResult); @@ -102,7 +101,10 @@ public void prepare(ResponseBuilder rb) { try { Query preFilterQuery = QParser.getParser("{!" + ReverseQueryParserPlugin.NAME + "}", req).parse(); - rb.setQuery(preFilterQuery); + List mutableFilters = + Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); + rb.setQuery(new MatchAllDocsQuery()); + mutableFilters.add(preFilterQuery); var searcher = req.getSearcher(); MonitorQueryCache solrMonitorCache = (SharedMonitorCache) searcher.getCache(SOLR_MONITOR_CACHE_NAME); @@ -110,7 +112,7 @@ public void prepare(ResponseBuilder rb) { mutableFilters.add( new MonitorPostFilter( new SolrMonitorQueryCollector.CollectorContext( - solrMonitorCache, queryDecoder, matcherSink, writeToDocList))); + solrMonitorCache, queryDecoder, matcherSink, writeToDocList, matchType))); rb.setFilters(mutableFilters); rb.rsp.add(QUERY_MATCH_TYPE_KEY, matchType.name()); if (matchType != QueryMatchType.NONE) { diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java index b111ccbfd460..409919744741 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java @@ -22,6 +22,7 @@ import java.io.IOException; import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.monitor.QCEVisitor; +import org.apache.lucene.search.ConstantScoreQuery; import org.apache.lucene.search.ScoreMode; import org.apache.solr.monitor.MonitorConstants; import org.apache.solr.monitor.MonitorDataValues; @@ -36,12 +37,14 @@ class SolrMonitorQueryCollector extends DelegatingCollector { private final SolrMatcherSink matcherSink; private final MonitorDataValues dataValues = new MonitorDataValues(); private final boolean writeToDocList; + private final QueryMatchType queryMatchType; SolrMonitorQueryCollector(CollectorContext collectorContext) { this.monitorQueryCache = collectorContext.queryCache; this.queryDecoder = collectorContext.queryDecoder; this.matcherSink = collectorContext.solrMatcherSink; this.writeToDocList = collectorContext.writeToDocList; + this.queryMatchType = collectorContext.queryMatchType; } @Override @@ -49,7 +52,12 @@ public void collect(int doc) throws IOException { dataValues.advanceTo(doc); var entry = getEntry(dataValues); var queryId = dataValues.getQueryId(); - boolean isMatch = matcherSink.matchQuery(queryId, entry.getMatchQuery(), entry.getMetadata()); + var originalMatchQuery = entry.getMatchQuery(); + var matchQuery = + queryMatchType.needsScores + ? originalMatchQuery + : new ConstantScoreQuery(originalMatchQuery); + boolean isMatch = matcherSink.matchQuery(queryId, matchQuery, entry.getMetadata()); if (isMatch && writeToDocList) { super.collect(doc); } @@ -91,16 +99,19 @@ static class CollectorContext { private final SolrMonitorQueryDecoder queryDecoder; private final SolrMatcherSink solrMatcherSink; private final boolean writeToDocList; + private final QueryMatchType queryMatchType; CollectorContext( MonitorQueryCache queryCache, SolrMonitorQueryDecoder queryDecoder, SolrMatcherSink solrMatcherSink, - boolean writeToDocList) { + boolean writeToDocList, + QueryMatchType queryMatchType) { this.queryCache = queryCache; this.queryDecoder = queryDecoder; this.solrMatcherSink = solrMatcherSink; this.writeToDocList = writeToDocList; + this.queryMatchType = queryMatchType; } } } From 60b0eb50b8805df0564180a1f7a1840a9f3133a2 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 12 Apr 2024 17:17:12 -0400 Subject: [PATCH 15/85] read MAX_SIZE_PARAM for maxSize --- .../java/org/apache/solr/monitor/cache/SharedMonitorCache.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java index 612c9c589c51..a8891c22e02f 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java @@ -93,7 +93,7 @@ private Map mqCacheMap() { @Override public Object init(Map args, Object persistence, CacheRegenerator regenerator) { super.init(args, regenerator); - String str = args.get(SIZE_PARAM); + String str = args.get(MAX_SIZE_PARAM); int maxSize = (str == null) ? 100_000 : Integer.parseInt(str); str = args.get(INITIAL_SIZE_PARAM); initialSize = Math.min((str == null) ? 10_000 : Integer.parseInt(str), maxSize); From fd04c4e3234a014909895b628613b25174e10bcf Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 12 Apr 2024 17:41:53 -0400 Subject: [PATCH 16/85] don't drop cause --- .../monitor/src/java/org/apache/lucene/monitor/QCEVisitor.java | 2 +- .../src/java/org/apache/solr/monitor/SimpleQueryParser.java | 3 +-- .../java/org/apache/solr/monitor/cache/SharedMonitorCache.java | 2 +- .../org/apache/solr/monitor/search/ReverseSearchComponent.java | 3 +-- 4 files changed, 4 insertions(+), 6 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/QCEVisitor.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/QCEVisitor.java index c09f6bef24be..a1ff2733b71e 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/QCEVisitor.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/QCEVisitor.java @@ -47,7 +47,7 @@ public static QCEVisitor getComponent( return qce; } } - throw new IllegalStateException("Corrupt monitorQuery value in index"); + throw new IllegalArgumentException("Corrupt monitorQuery value in index"); } public Query getMatchQuery() { diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/SimpleQueryParser.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/SimpleQueryParser.java index ca587cdc34f1..69bd70d5a16b 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/SimpleQueryParser.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/SimpleQueryParser.java @@ -23,7 +23,6 @@ import java.util.HashMap; import java.util.Map; import org.apache.lucene.search.Query; -import org.apache.solr.common.SolrException; import org.apache.solr.common.params.MapSolrParams; import org.apache.solr.common.params.SolrParams; import org.apache.solr.common.util.ContentStream; @@ -59,7 +58,7 @@ public static Query parse(String queryStr, SolrCore core) { try { return QParser.getParser(queryStr, new SimpleQueryParser(core)).parse(); } catch (SyntaxError e) { - throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "could not parse query"); + throw new IllegalStateException("could not parse query", e); } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java index a8891c22e02f..d14f5504615e 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java @@ -147,7 +147,7 @@ public VersionedQueryCacheEntry computeIfAbsent( try { return mappingFunction.apply(_key); } catch (IOException e) { - throw new SolrException(ErrorCode.INVALID_STATE, "Could not update cache"); + throw new SolrException(ErrorCode.INVALID_STATE, "Could not update cache", e); } }); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 99e2f5bc3f7c..1aef56e628f4 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -119,8 +119,7 @@ public void prepare(ResponseBuilder rb) { rb.rsp.add(MONITOR_OUTPUT_KEY, monitorResult); } } catch (SyntaxError e) { - throw new SolrException( - SolrException.ErrorCode.BAD_REQUEST, "Syntax error in query: " + e.getMessage()); + throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "Syntax error in query: ", e); } } From 32cb6f6cae90f4beea43fc86b835c96953f191a7 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 12 Apr 2024 17:48:01 -0400 Subject: [PATCH 17/85] remove superstitious delete calls --- .../org/apache/solr/monitor/MonitorSolrQueryTest.java | 10 ---------- .../solr/monitor/ParallelMonitorSolrQueryTest.java | 1 - .../solr/monitor/StoredMonitorSolrQueryTest.java | 1 - 3 files changed, 12 deletions(-) diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java index 03d77bca6ca4..6856b490a7e5 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java @@ -50,7 +50,6 @@ public class MonitorSolrQueryTest extends BaseDistributedSearchTestCase { @Test @ShardsFixed(num = 3) public void testMonitorQuery() throws Exception { - del("*:*"); index(id, Integer.toString(0), "_mq", "content_s:\"elevator music\""); index( id, @@ -126,7 +125,6 @@ public void testMonitorQuery() throws Exception { @Test @ShardsFixed(num = 3) public void testNoDocListInResponse() throws Exception { - del("*:*"); index(id, Integer.toString(0), "_mq", "content_s:\"elevator music\""); index( id, @@ -167,7 +165,6 @@ public void testNoDocListInResponse() throws Exception { @Test public void testDefaultParser() throws Exception { - del("*:*"); index(id, Integer.toString(0), "_mq", "content_s:\"elevator stairs\""); index(id, Integer.toString(1), "_mq", "content_s:\"something else\""); commit(); @@ -198,7 +195,6 @@ public void testDefaultParser() throws Exception { @Test @ShardsFixed(num = 2) public void testDisjunctionQuery() throws Exception { - del("*:*"); index( id, Integer.toString(0), @@ -238,7 +234,6 @@ public void testDisjunctionQuery() throws Exception { @Test public void testNoDanglingDecomposition() throws Exception { - del("*:*"); index( id, Integer.toString(0), @@ -286,7 +281,6 @@ public void testNoDanglingDecomposition() throws Exception { @Test public void testNotQuery() throws Exception { - del("*:*"); index(id, Integer.toString(0), "_mq", "*:* -content0_s:\"elevator stairs\""); index(id, Integer.toString(1), "_mq", "*:* -content_s:\"candy canes\""); commit(); @@ -315,7 +309,6 @@ public void testNotQuery() throws Exception { @Test public void testWildCardQuery() throws Exception { - del("*:*"); index(id, Integer.toString(0), "_mq", "content_s:te*"); index(id, Integer.toString(1), "_mq", "content_s:tes*"); index(id, Integer.toString(2), "_mq", "content_s:test*"); @@ -352,7 +345,6 @@ public void testWildCardQuery() throws Exception { @Test @ShardsFixed(num = 2) public void testDefaultQueryMatchTypeIsNone() throws Exception { - del("*:*"); index(id, Integer.toString(0), "_mq", "content_s:\"elevator stairs\""); index(id, Integer.toString(1), "_mq", "content_s:\"something else\""); commit(); @@ -383,7 +375,6 @@ public void testDefaultQueryMatchTypeIsNone() throws Exception { @Test @ShardsFixed(num = 2) public void testMultiDocHighlightMatchType() throws Exception { - del("*:*"); index(id, Integer.toString(0), "_mq", "content0_offset_s:\"elevator stairs\""); index( id, @@ -451,7 +442,6 @@ public void testMultiDocHighlightMatchType() throws Exception { @Test public void testHighlightMatchType() throws Exception { - del("*:*"); index(id, Integer.toString(0), "_mq", "content0_s:\"elevator stairs\""); index( id, diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java index 5b8848ffebb8..a5ad4776a820 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java @@ -44,7 +44,6 @@ protected boolean supportsWriteToDocList() { @Test public void manySegmentsQuery() throws Exception { - del("*:*"); int count = 10_000; IntStream.range(0, count) .forEach( diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java index cbdfee6d06d7..a36f4ed77e01 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java @@ -31,7 +31,6 @@ public static void beforeSuperClass() { @Test public void indexBigQueryTest() throws Exception { - del("*:*"); index( id, Integer.toString(0), "_mq", "{!xmlparser}" + read("/monitor/BigDisjunctionQuery.xml")); commit(); From b6d369b334fba8399ca745574ef2752edaeda59e Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 12 Apr 2024 18:01:42 -0400 Subject: [PATCH 18/85] add testDeleteByQueryId --- .../solr/monitor/MonitorSolrQueryTest.java | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java index 6856b490a7e5..a1d39a7198ba 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java @@ -497,6 +497,44 @@ public void testHighlightMatchType() throws Exception { } } + @Test + public void testDeleteByQueryId() throws Exception { + index( + id, + Integer.toString(0), + "_mq", + "{!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"), + REVERSE_SEARCH_PARAM_NAME, + true, + WRITE_TO_DOC_LIST_KEY, + supportsWriteToDocList(), + QUERY_MATCH_TYPE_KEY, + "simple" + }; + + QueryResponse response = query(params); + if (supportsWriteToDocList()) { + assertEquals(1, ((SolrDocumentList) response.getResponse().get("response")).size()); + } + validate(response, 0, List.of("0")); + + del(MonitorFields.QUERY_ID + ":0"); + commit(); + response = query(CommonParams.Q, "*:*"); + assertEquals(0, ((SolrDocumentList) response.getResponse().get("response")).size()); + } + static Map queryMatch( String queryId, String field1, From 0ab5a6bbe788d12732545fd298b848229444cee6 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Sat, 13 Apr 2024 18:14:21 -0400 Subject: [PATCH 19/85] enable setting maxRamMB for monitor cache --- .../monitor/cache/SharedMonitorCache.java | 31 ++++++++++++++----- .../solr/collection1/solrconfig-parallel.xml | 1 + .../solr/collection1/solrconfig.xml | 1 + 3 files changed, 26 insertions(+), 7 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java index d14f5504615e..106467ea262d 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java @@ -34,6 +34,7 @@ import org.apache.lucene.monitor.QCEVisitor; import org.apache.lucene.monitor.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; @@ -71,6 +72,8 @@ public class SharedMonitorCache extends SolrCacheBase // 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( @@ -94,7 +97,9 @@ private Map mqCacheMap() { public Object init(Map args, Object persistence, CacheRegenerator regenerator) { super.init(args, regenerator); String str = args.get(MAX_SIZE_PARAM); - int maxSize = (str == null) ? 100_000 : Integer.parseInt(str); + 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); @@ -102,17 +107,27 @@ public Object init(Map args, Object persistence, CacheRegenerato if (str != null) { maxIdleTimeSec = Integer.parseInt(str); } - mqCache = buildCache(maxSize, maxIdleTimeSec); + mqCache = buildCache(maxIdleTimeSec); return persistence; } - private Cache buildCache(int maxSize, int maxIdleTimeSec) { + private Cache buildCache(int maxIdleTimeSec) { Caffeine builder = Caffeine.newBuilder().initialCapacity(initialSize).removalListener(this).recordStats(); if (maxIdleTimeSec > 0) { builder.expireAfterAccess(Duration.ofSeconds(maxIdleTimeSec)); } - builder.maximumSize(maxSize); + + 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(); } @@ -181,13 +196,13 @@ public void warm(SolrIndexSearcher searcher, SolrCache true 20 diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml index c9d5dc2156a9..762d82f245a0 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml @@ -69,6 +69,7 @@ class="org.apache.solr.monitor.cache.SharedMonitorCache" async="false" regenerator="org.apache.solr.monitor.cache.SharedMonitorCacheLatestRegenerator" + maxSize="2" maxIdleTime="100000"/> true 20 From 0b0120e09a068d03d98697c95c7d06a4122e7c1d Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Mon, 15 Apr 2024 11:10:34 -0400 Subject: [PATCH 20/85] hardcoding luceneMatchVersion is bad --- .../src/test-files/solr/collection1/solrconfig-no-cache.xml | 2 +- .../src/test-files/solr/collection1/solrconfig-parallel.xml | 2 +- .../monitor/src/test-files/solr/collection1/solrconfig.xml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml index dabf463a2423..2d4f2592875f 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml @@ -19,7 +19,7 @@ --> - 9.4 + ${tests.luceneMatchVersion:LATEST} ${solr.data.dir:} diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml index 88eb97a25c15..1e32fecf3960 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml @@ -19,7 +19,7 @@ --> - 9.4 + ${tests.luceneMatchVersion:LATEST} ${solr.data.dir:} diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml index 762d82f245a0..8417d07d5d14 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml @@ -19,7 +19,7 @@ --> - 9.4 + ${tests.luceneMatchVersion:LATEST} ${solr.data.dir:} From 24c1bf5a961fa2c1c7b386c0edba75c373879d44 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 19 Apr 2024 18:32:37 -0400 Subject: [PATCH 21/85] add multi-pass presearcher and optional field aliasing --- .../apache/lucene/monitor/MonitorFields.java | 3 +- ...asingMultipassTermFilteredPresearcher.java | 62 +++++++++ .../solr/monitor/AliasingPresearcher.java | 82 +++++++++++ .../AliasingTermFilteredPresearcher.java | 78 +++++++++++ .../solr/monitor/MonitorDataValues.java | 4 +- .../solr/monitor/PresearcherFactory.java | 45 ------ .../SharedMonitorCacheLatestRegenerator.java | 5 +- .../monitor/search/PresearcherFactory.java | 129 ++++++++++++++++++ .../search/ReverseQueryParserPlugin.java | 60 +++++++- .../update/MonitorUpdateProcessorFactory.java | 18 ++- .../solr/collection1/schema-aliasing.xml | 105 ++++++++++++++ .../solr/collection1/solrconfig-no-cache.xml | 9 +- .../solr/collection1/solrconfig-parallel.xml | 10 +- .../solr/collection1/solrconfig.xml | 8 +- .../monitor/NoCacheMonitorSolrQueryTest.java | 1 + .../monitor/ParallelMonitorSolrQueryTest.java | 72 +++++++++- 16 files changed, 615 insertions(+), 76 deletions(-) create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingMultipassTermFilteredPresearcher.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingTermFilteredPresearcher.java delete mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/PresearcherFactory.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/PresearcherFactory.java create mode 100644 solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java index 9daa7c1bdbdb..46fdb8e13319 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java @@ -28,7 +28,8 @@ public class MonitorFields { public static final String MONITOR_QUERY = QueryIndex.FIELDS.mq; public static final String PAYLOAD = QueryIndex.FIELDS.mq + "_payload"; public static final String VERSION = "_version_"; + public static final String ANYTOKEN_FIELD = TermFilteredPresearcher.ANYTOKEN_FIELD; public static final Set RESERVED_MONITOR_FIELDS = - Set.of(QUERY_ID, CACHE_ID, MONITOR_QUERY, PAYLOAD, VERSION); + Set.of(QUERY_ID, CACHE_ID, MONITOR_QUERY, PAYLOAD, VERSION, ANYTOKEN_FIELD); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingMultipassTermFilteredPresearcher.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingMultipassTermFilteredPresearcher.java new file mode 100644 index 000000000000..ebf0dc1726e0 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingMultipassTermFilteredPresearcher.java @@ -0,0 +1,62 @@ +/* + * + * * 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.monitor; + +import static org.apache.solr.monitor.AliasingTermFilteredPresearcher.AliasingDocumentQueryBuilder; + +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.TermWeightor; + +public class AliasingMultipassTermFilteredPresearcher extends MultipassTermFilteredPresearcher { + + private final String prefix; + + private AliasingMultipassTermFilteredPresearcher( + 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 AliasingDocumentQueryBuilder(super.getQueryBuilder(), prefix); + } + + public static AliasingPresearcher build( + int passes, + float minWeight, + TermWeightor weightor, + List queryHandlers, + Set filterFields, + String prefix) { + return new AliasingPresearcher( + new AliasingMultipassTermFilteredPresearcher( + passes, minWeight, weightor, queryHandlers, filterFields, prefix), + prefix); + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java new file mode 100644 index 000000000000..db6476345ef5 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java @@ -0,0 +1,82 @@ +/* + * + * * 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.monitor; + +import java.util.Map; +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.MonitorFields; +import org.apache.lucene.monitor.Presearcher; +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 fields 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.monitor.ParallelMonitorSolrQueryTest#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); + } + + private Document alias(Document in) { + Document out = new Document(); + for (var field : in) { + if (!MonitorFields.RESERVED_MONITOR_FIELDS.contains(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; + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingTermFilteredPresearcher.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingTermFilteredPresearcher.java new file mode 100644 index 000000000000..92b879e436d7 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingTermFilteredPresearcher.java @@ -0,0 +1,78 @@ +/* + * + * * 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.monitor; + +import java.io.IOException; +import java.util.List; +import java.util.Set; +import org.apache.lucene.monitor.CustomQueryHandler; +import org.apache.lucene.monitor.TermFilteredPresearcher; +import org.apache.lucene.monitor.TermWeightor; +import org.apache.lucene.search.Query; +import org.apache.lucene.util.BytesRef; + +public class AliasingTermFilteredPresearcher extends TermFilteredPresearcher { + + private final String prefix; + + AliasingTermFilteredPresearcher( + 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 AliasingTermFilteredPresearcher(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/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java index bd2ddfbc09b5..7e7a286e0513 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java @@ -47,8 +47,9 @@ public void update(LeafReaderContext context) throws IOException { currentDoc = DocIdSetIterator.NO_MORE_DOCS; } - public void advanceTo(int doc) { + public boolean advanceTo(int doc) throws IOException { currentDoc = doc; + return cacheIdIt.advanceExact(currentDoc); } public String getQueryId() throws IOException { @@ -57,7 +58,6 @@ public String getQueryId() throws IOException { } public String getCacheId() throws IOException { - cacheIdIt.advanceExact(currentDoc); return cacheIdIt.lookupOrd(cacheIdIt.ordValue()).utf8ToString(); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/PresearcherFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/PresearcherFactory.java deleted file mode 100644 index f48cf451b597..000000000000 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/PresearcherFactory.java +++ /dev/null @@ -1,45 +0,0 @@ -/* - * - * * 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.monitor; - -import org.apache.lucene.monitor.MultipassTermFilteredPresearcher; -import org.apache.lucene.monitor.Presearcher; -import org.apache.lucene.monitor.TermFilteredPresearcher; - -public class PresearcherFactory { - - public static final String TERM_FILTERED = TermFilteredPresearcher.class.getSimpleName(); - public static final String MULTI_PASS_TERM_FILTERED = - MultipassTermFilteredPresearcher.class.getSimpleName(); - - public static Presearcher build() { - return build(null); - } - - public static Presearcher build(Object type) { - if (TERM_FILTERED.equals(type)) { - return new TermFilteredPresearcher(); - } - if (MULTI_PASS_TERM_FILTERED.equals(type)) { - return new MultipassTermFilteredPresearcher(3); - } - return Presearcher.NO_FILTERING; - } -} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java index aa79f449b24c..ec02c427476f 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java @@ -69,8 +69,9 @@ public boolean regenerateItem( && topDocs[docIndex].doc < shiftedMax) { int doc = topDocs[docIndex].doc - ctx.docBase; docIndex++; - dataValues.advanceTo(doc); - cache.computeIfStale(dataValues, decoder); + if (dataValues.advanceTo(doc)) { + cache.computeIfStale(dataValues, decoder); + } cache.versionHighWaterMark = Math.max(cache.versionHighWaterMark, dataValues.getVersion()); cache.docVisits++; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/PresearcherFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/PresearcherFactory.java new file mode 100644 index 000000000000..df940053ca88 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/PresearcherFactory.java @@ -0,0 +1,129 @@ +/* + * + * * 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.monitor.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.monitor.AliasingMultipassTermFilteredPresearcher; +import org.apache.solr.monitor.AliasingTermFilteredPresearcher; + +public class PresearcherFactory { + + 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 = + AliasingTermFilteredPresearcher.build( + weightor, customQueryHandlers, filterFields, presearcherParameters.aliasPrefix); + } else { + presearcher = new TermFilteredPresearcher(weightor, customQueryHandlers, filterFields); + } + } else { + if (presearcherParameters.applyFieldNameAlias) { + presearcher = + AliasingMultipassTermFilteredPresearcher.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); + } + } + + static class PresearcherParameters { + + private final String presearcherType; + private final String termWeightorType; + private final boolean applyFieldNameAlias; + private final int numberOfPasses; + private final float minWeight; + private final String aliasPrefix; + + public PresearcherParameters( + String presearcherType, + String termWeightorType, + boolean applyFieldNameAlias, + int numberOfPasses, + float minWeight, + String aliasPrefix) { + this.presearcherType = presearcherType; + this.termWeightorType = termWeightorType; + this.applyFieldNameAlias = applyFieldNameAlias; + this.numberOfPasses = numberOfPasses; + this.minWeight = minWeight; + this.aliasPrefix = aliasPrefix; + } + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParserPlugin.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParserPlugin.java index ba623bab8dc3..bc0eb2010bc1 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParserPlugin.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParserPlugin.java @@ -19,21 +19,33 @@ package org.apache.solr.monitor.search; +import static org.apache.solr.monitor.search.PresearcherFactory.PresearcherParameters; + import java.io.IOException; +import java.util.Optional; import org.apache.lucene.monitor.Presearcher; +import org.apache.lucene.util.ResourceLoader; +import org.apache.lucene.util.ResourceLoaderAware; import org.apache.solr.common.params.SolrParams; import org.apache.solr.common.util.NamedList; -import org.apache.solr.monitor.PresearcherFactory; import org.apache.solr.request.SolrQueryRequest; import org.apache.solr.search.QParser; import org.apache.solr.search.QParserPlugin; -public class ReverseQueryParserPlugin extends QParserPlugin { +public class ReverseQueryParserPlugin extends QParserPlugin implements ResourceLoaderAware { public static final String NAME = "reverse"; - // TODO parameterize this - private Presearcher presearcher = PresearcherFactory.build(PresearcherFactory.TERM_FILTERED); + // 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. + private static final String DEFAULT_ALIAS_PREFIX = + "________________________________monitor_alias_"; + + private Presearcher presearcher; + private PresearcherParameters presearcherParameters; @Override public QParser createParser( @@ -49,5 +61,45 @@ public void close() throws IOException { @Override public void init(NamedList args) { super.init(args); + String presearcherType = (String) args.get("presearcherType"); + String termWeightorType = (String) args.get("termWeightorType"); + boolean applyFieldNameAlias = + resolveProperty(args, "applyFieldNameAlias", Boolean.class, false); + int numberOfPasses = resolveProperty(args, "numberOfPasses", Integer.class, 0); + float minWeight = resolveProperty(args, "minWeight", Float.class, 0f); + String aliasPrefix = + Optional.ofNullable((String) args.get("aliasPrefix")).orElse(DEFAULT_ALIAS_PREFIX); + presearcherParameters = + new PresearcherParameters( + presearcherType, + termWeightorType, + applyFieldNameAlias, + numberOfPasses, + minWeight, + aliasPrefix); + } + + // TODO is there a better pattern for this? NamedList::get(String key, T default) can't be called + // on NamedList + @SuppressWarnings("unchecked") + private T resolveProperty( + NamedList args, String propertyName, Class clazz, T defaultVal) { + Object obj = args.get(propertyName); + if (obj == null) { + return defaultVal; + } + if (clazz.isInstance(obj)) { + return (T) obj; + } + throw new IllegalArgumentException(propertyName + " must be a " + clazz.getSimpleName()); + } + + @Override + public void inform(ResourceLoader loader) throws IOException { + presearcher = PresearcherFactory.build(loader, presearcherParameters); + } + + public Presearcher getPresearcher() { + return presearcher; } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java index 321f7a43887f..848b03d5f28f 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java @@ -22,15 +22,18 @@ import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.monitor.Presearcher; import org.apache.solr.common.util.NamedList; -import org.apache.solr.monitor.PresearcherFactory; +import org.apache.solr.core.SolrCore; +import org.apache.solr.monitor.search.ReverseQueryParserPlugin; import org.apache.solr.request.SolrQueryRequest; import org.apache.solr.response.SolrQueryResponse; import org.apache.solr.update.processor.UpdateRequestProcessor; import org.apache.solr.update.processor.UpdateRequestProcessorFactory; +import org.apache.solr.util.plugin.SolrCoreAware; -public class MonitorUpdateProcessorFactory extends UpdateRequestProcessorFactory { +public class MonitorUpdateProcessorFactory extends UpdateRequestProcessorFactory + implements SolrCoreAware { - private Presearcher presearcher = PresearcherFactory.build(); + private Presearcher presearcher; private String queryFieldNameOverride; private String payloadFieldNameOverride; @@ -48,9 +51,14 @@ public UpdateRequestProcessor getInstance( @Override public void init(NamedList args) { super.init(args); - Object presearcherType = args.get("presearcherType"); - presearcher = PresearcherFactory.build(presearcherType); queryFieldNameOverride = (String) args.get("queryFieldName"); payloadFieldNameOverride = (String) args.get("payloadFieldName"); } + + @Override + public void inform(SolrCore core) { + presearcher = + ((ReverseQueryParserPlugin) core.getQueryPlugin(ReverseQueryParserPlugin.NAME)) + .getPresearcher(); + } } diff --git a/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml b/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml new file mode 100644 index 000000000000..2eb516f0237d --- /dev/null +++ b/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml @@ -0,0 +1,105 @@ + + + + + + id + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml index 2d4f2592875f..a3a9682c74f0 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml @@ -165,9 +165,7 @@ - - TermFilteredPresearcher - + @@ -181,5 +179,8 @@ + class="org.apache.solr.monitor.search.ReverseQueryParserPlugin"> + TermFilteredPresearcher + true + diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml index 1e32fecf3960..5c59fe82924b 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml @@ -172,9 +172,7 @@ - - TermFilteredPresearcher - + @@ -188,5 +186,9 @@ + class="org.apache.solr.monitor.search.ReverseQueryParserPlugin"> + MultipassTermFilteredPresearcher + true + 4 + diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml index 8417d07d5d14..321e85228c41 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml @@ -171,9 +171,7 @@ - - TermFilteredPresearcher - + @@ -187,5 +185,7 @@ + class="org.apache.solr.monitor.search.ReverseQueryParserPlugin"> + TermFilteredPresearcher + diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/NoCacheMonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/NoCacheMonitorSolrQueryTest.java index 9e734553f8e7..d47ba425f48f 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/NoCacheMonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/NoCacheMonitorSolrQueryTest.java @@ -26,5 +26,6 @@ public class NoCacheMonitorSolrQueryTest extends MonitorSolrQueryTest { @BeforeClass public static void beforeSuperClass() { configString = "solrconfig-no-cache.xml"; + schemaString = "schema-aliasing.xml"; } } diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java index a5ad4776a820..98f23fdc1744 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java @@ -35,14 +35,11 @@ public class ParallelMonitorSolrQueryTest extends MonitorSolrQueryTest { @BeforeClass public static void beforeSuperClass() { configString = "solrconfig-parallel.xml"; - } - - @Override - protected boolean supportsWriteToDocList() { - return false; + schemaString = "schema-aliasing.xml"; } @Test + @SuppressWarnings("rawtypes") public void manySegmentsQuery() throws Exception { int count = 10_000; IntStream.range(0, count) @@ -110,4 +107,69 @@ public void manySegmentsQuery() throws Exception { .get("queries")) .size()); } + + @Test + public void coexistWithRegularDocumentsTest() throws Exception { + index(id, "0", "content_s", "some unremarkable content"); + index( + id, + "1", + "________________________________monitor_alias_content_s_0", + "some more unremarkable content"); + commit(); + index(id, "2", "_mq", "content_s:test"); + commit(); + handle.clear(); + handle.put("responseHeader", SKIP); + handle.put("response", SKIP); + + Object[] params = + new Object[] { + CommonParams.SORT, + id + " desc", + CommonParams.JSON, + read("/monitor/multi-doc-batch.json"), + REVERSE_SEARCH_PARAM_NAME, + true, + QUERY_MATCH_TYPE_KEY, + "simple" + }; + + QueryResponse response = query(params); + validate(response, 4, 0, "2"); + } + + @Test + @SuppressWarnings("unchecked") + public void multiPassPresearcherTest() throws Exception { + index(id, "0", "_mq", "content0_s:\"elevator stairs and escalator\""); + index(id, "1", "_mq", "content0_s:\"elevator test\""); + index(id, "2", "_mq", "content0_s:\"stairs test\""); + index(id, "3", "_mq", "content0_s:\"elevator stairs\""); + commit(); + handle.clear(); + handle.put("responseHeader", SKIP); + handle.put("response", SKIP); + + Object[] params = + new Object[] { + CommonParams.SORT, + id + " desc", + CommonParams.JSON, + read("/monitor/single-doc-batch.json"), + REVERSE_SEARCH_PARAM_NAME, + true, + QUERY_MATCH_TYPE_KEY, + "simple" + }; + + QueryResponse response = query(params); + assertEquals(1, ((Map) response.getResponse().get("monitor")).get("queriesRun")); + validate(response, 0, 0, "3"); + } + + @Override + protected boolean supportsWriteToDocList() { + return false; + } } From ee2992de0423476a74dbfc658fe14a41674fd02f Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 19 Apr 2024 18:45:32 -0400 Subject: [PATCH 22/85] more accurate error Co-authored-by: Christine Poerschke --- .../java/org/apache/solr/monitor/search/ReverseQueryParser.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParser.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParser.java index 88584bfe95db..c298e3875eb1 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParser.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParser.java @@ -52,7 +52,7 @@ public ReverseQueryParser( public Query parse() throws SyntaxError { var obj = req.getContext().get(DOCUMENT_BATCH_KEY); if (!(obj instanceof DocumentBatchVisitor)) { - throw new SyntaxError("Document Batch is of unexpected type"); + throw new SyntaxError(DOCUMENT_BATCH_KEY + " is absent or of unexpected type: " + obj); } var documentBatch = (DocumentBatchVisitor) obj; LeafReader queryIndexReader = documentBatch.get(); From 6815ea1d68a85b488094ffeb7076595528b1ff9f Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 19 Apr 2024 18:46:20 -0400 Subject: [PATCH 23/85] redundant override Co-authored-by: Christine Poerschke --- .../apache/solr/monitor/search/ReverseSearchComponent.java | 4 ---- 1 file changed, 4 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 1aef56e628f4..2ed3089f8089 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -170,10 +170,6 @@ public void handleResponses(ResponseBuilder rb, ShardRequest sreq) { } } - @Override - public void finishStage(ResponseBuilder rb) { - super.finishStage(rb); - } @Override public String getDescription() { From 995cfa26437b9f396bb9c0da911206bcd2288c9e Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Wed, 24 Apr 2024 16:38:00 -0400 Subject: [PATCH 24/85] wrap reserved field with _ and remove override behavior --- .../apache/lucene/monitor/MonitorFields.java | 8 +- .../search/ReverseSearchComponent.java | 1 - .../update/MonitorUpdateProcessorFactory.java | 18 +-- .../update/MonitorUpdateRequestProcessor.java | 14 +-- .../solr/collection1/schema-aliasing.xml | 10 +- .../solr/collection1/schema-stored-mq.xml | 10 +- .../test-files/solr/collection1/schema.xml | 10 +- .../solr/monitor/MonitorSolrQueryTest.java | 106 ++++++++++-------- .../monitor/ParallelMonitorSolrQueryTest.java | 19 ++-- .../monitor/StoredMonitorSolrQueryTest.java | 6 +- 10 files changed, 100 insertions(+), 102 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java index 46fdb8e13319..52fc69f74c52 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java @@ -23,10 +23,10 @@ public 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 String PAYLOAD = QueryIndex.FIELDS.mq + "_payload"; + 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 String PAYLOAD = QueryIndex.FIELDS.mq + "_payload_"; public static final String VERSION = "_version_"; public static final String ANYTOKEN_FIELD = TermFilteredPresearcher.ANYTOKEN_FIELD; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 2ed3089f8089..0bd2901c3fb9 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -170,7 +170,6 @@ public void handleResponses(ResponseBuilder rb, ShardRequest sreq) { } } - @Override public String getDescription() { return "Component that integrates with lucene monitor for reverse search."; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java index 848b03d5f28f..a47cf72c7c5b 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java @@ -19,9 +19,7 @@ package org.apache.solr.monitor.update; -import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.monitor.Presearcher; -import org.apache.solr.common.util.NamedList; import org.apache.solr.core.SolrCore; import org.apache.solr.monitor.search.ReverseQueryParserPlugin; import org.apache.solr.request.SolrQueryRequest; @@ -34,25 +32,11 @@ public class MonitorUpdateProcessorFactory extends UpdateRequestProcessorFactory implements SolrCoreAware { private Presearcher presearcher; - private String queryFieldNameOverride; - private String payloadFieldNameOverride; @Override public UpdateRequestProcessor getInstance( SolrQueryRequest req, SolrQueryResponse rsp, UpdateRequestProcessor next) { - String queryFieldName = - queryFieldNameOverride == null ? MonitorFields.MONITOR_QUERY : queryFieldNameOverride; - String payloadFieldName = - payloadFieldNameOverride == null ? MonitorFields.PAYLOAD : payloadFieldNameOverride; - return new MonitorUpdateRequestProcessor( - next, queryFieldName, req.getCore(), presearcher, payloadFieldName); - } - - @Override - public void init(NamedList args) { - super.init(args); - queryFieldNameOverride = (String) args.get("queryFieldName"); - payloadFieldNameOverride = (String) args.get("payloadFieldName"); + return new MonitorUpdateRequestProcessor(next, req.getCore(), presearcher); } @Override diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java index 37eb9b8a0979..af2cbd72d948 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java @@ -55,22 +55,14 @@ public class MonitorUpdateRequestProcessor extends UpdateRequestProcessor { - private final String queryFieldName; - private final String payloadFieldName; private final SolrCore core; private final IndexSchema indexSchema; private final Presearcher presearcher; private final MonitorSchemaFields monitorSchemaFields; public MonitorUpdateRequestProcessor( - UpdateRequestProcessor next, - String queryFieldName, - SolrCore core, - Presearcher presearcher, - String payloadFieldName) { + UpdateRequestProcessor next, SolrCore core, Presearcher presearcher) { super(next); - this.queryFieldName = queryFieldName; - this.payloadFieldName = payloadFieldName; this.core = core; this.indexSchema = core.getLatestSchema(); this.presearcher = presearcher; @@ -82,10 +74,10 @@ public void processAdd(AddUpdateCommand cmd) throws IOException { var solrInputDocument = cmd.getSolrInputDocument(); var queryId = (String) solrInputDocument.getFieldValue(indexSchema.getUniqueKeyField().getName()); - var queryFieldValue = solrInputDocument.getFieldValue(queryFieldName); + var queryFieldValue = solrInputDocument.getFieldValue(MonitorFields.MONITOR_QUERY); if (queryFieldValue != null) { var payload = - Optional.ofNullable(solrInputDocument.getFieldValue(payloadFieldName)) + Optional.ofNullable(solrInputDocument.getFieldValue(MonitorFields.PAYLOAD)) .map(Object::toString) .orElse(null); List children = diff --git a/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml b/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml index 2eb516f0237d..36d88e15fb04 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml @@ -89,15 +89,15 @@ - - - - - diff --git a/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml b/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml index 2014e706bcf0..bb0d92faa605 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml @@ -87,14 +87,14 @@ - - - - - + + \ No newline at end of file diff --git a/solr/modules/monitor/src/test-files/solr/collection1/schema.xml b/solr/modules/monitor/src/test-files/solr/collection1/schema.xml index c52cd215ce83..2ff2a10085f0 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/schema.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/schema.xml @@ -87,15 +87,15 @@ - - - - - diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java index a1d39a7198ba..d2a72012dbb2 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java @@ -50,18 +50,24 @@ public class MonitorSolrQueryTest extends BaseDistributedSearchTestCase { @Test @ShardsFixed(num = 3) public void testMonitorQuery() throws Exception { - index(id, Integer.toString(0), "_mq", "content_s:\"elevator music\""); + index(id, Integer.toString(0), MonitorFields.MONITOR_QUERY, "content_s:\"elevator music\""); index( id, Integer.toString(1), - "_mq", + MonitorFields.MONITOR_QUERY, "{!xmlparser}steep stairs"); - index(id, Integer.toString(2), "_mq", "content_s:\"elevator sounds\""); - index(id, Integer.toString(3), "_mq", "content_s:\"elevator drop\""); - index(id, Integer.toString(4), "_mq", "content_s:\"elevator stairs\""); - index(id, Integer.toString(5), "_mq", "other_content_s:\"solr is cool\""); - index(id, Integer.toString(6), "_mq", "other_content_s:\"solr is lame\""); - index(id, Integer.toString(7), "_mq", "content_s:something", "_mq_payload", "some metadata"); + 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", + MonitorFields.PAYLOAD, + "some metadata"); commit(); handle.clear(); handle.put("responseHeader", SKIP); @@ -70,7 +76,7 @@ public void testMonitorQuery() throws Exception { Object[] params = new Object[] { CommonParams.SORT, - "_query_id desc", + MonitorFields.QUERY_ID + " desc", CommonParams.JSON, read("/monitor/multi-doc-batch.json"), REVERSE_SEARCH_PARAM_NAME, @@ -85,14 +91,14 @@ public void testMonitorQuery() throws Exception { validate(response, 2, List.of("5")); assertEquals(0, ((SolrDocumentList) response.getResponse().get("response")).size()); - index(id, Integer.toString(5), "_mq", "other_content_s:\"solr is lame\""); - index(id, Integer.toString(6), "_mq", "other_content_s:\"solr is cool\""); + 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), - "_mq", + MonitorFields.MONITOR_QUERY, "{!xmlparser}steep hill"); - index(id, Integer.toString(2), "_mq", "content_s:elevator"); + index(id, Integer.toString(2), MonitorFields.MONITOR_QUERY, "content_s:elevator"); commit(); handle.clear(); handle.put("responseHeader", SKIP); @@ -125,18 +131,18 @@ public void testMonitorQuery() throws Exception { @Test @ShardsFixed(num = 3) public void testNoDocListInResponse() throws Exception { - index(id, Integer.toString(0), "_mq", "content_s:\"elevator music\""); + index(id, Integer.toString(0), MonitorFields.MONITOR_QUERY, "content_s:\"elevator music\""); index( id, Integer.toString(1), - "_mq", + MonitorFields.MONITOR_QUERY, "{!xmlparser}steep stairs"); - index(id, Integer.toString(2), "_mq", "content_s:\"elevator sounds\""); - index(id, Integer.toString(3), "_mq", "content_s:\"elevator drop\""); - index(id, Integer.toString(4), "_mq", "content_s:\"elevator stairs\""); - index(id, Integer.toString(5), "_mq", "other_content_s:\"solr is cool\""); - index(id, Integer.toString(6), "_mq", "other_content_s:\"solr is lame\""); - index(id, Integer.toString(7), "_mq", "content_s:something"); + 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); @@ -145,7 +151,7 @@ public void testNoDocListInResponse() throws Exception { Object[] params = new Object[] { CommonParams.SORT, - "_query_id desc", + MonitorFields.QUERY_ID + " desc", CommonParams.JSON, read("/monitor/multi-doc-batch.json"), REVERSE_SEARCH_PARAM_NAME, @@ -165,8 +171,8 @@ public void testNoDocListInResponse() throws Exception { @Test public void testDefaultParser() throws Exception { - index(id, Integer.toString(0), "_mq", "content_s:\"elevator stairs\""); - index(id, Integer.toString(1), "_mq", "content_s:\"something else\""); + 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); @@ -198,12 +204,12 @@ public void testDisjunctionQuery() throws Exception { index( id, Integer.toString(0), - "_mq", + MonitorFields.MONITOR_QUERY, "{!xmlparser}elevatorwindastufen"); index( id, Integer.toString(1), - "_mq", + MonitorFields.MONITOR_QUERY, "{!xmlparser}nottheseterms"); commit(); handle.clear(); @@ -237,7 +243,7 @@ public void testNoDanglingDecomposition() throws Exception { index( id, Integer.toString(0), - "_mq", + MonitorFields.MONITOR_QUERY, "{!xmlparser}elevatorlift"); commit(); handle.clear(); @@ -268,7 +274,7 @@ public void testNoDanglingDecomposition() throws Exception { index( id, Integer.toString(0), - "_mq", + MonitorFields.MONITOR_QUERY, "{!xmlparser}elevator"); commit(); response = query(params); @@ -281,8 +287,12 @@ public void testNoDanglingDecomposition() throws Exception { @Test public void testNotQuery() throws Exception { - index(id, Integer.toString(0), "_mq", "*:* -content0_s:\"elevator stairs\""); - index(id, Integer.toString(1), "_mq", "*:* -content_s:\"candy canes\""); + 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); @@ -309,11 +319,11 @@ public void testNotQuery() throws Exception { @Test public void testWildCardQuery() throws Exception { - index(id, Integer.toString(0), "_mq", "content_s:te*"); - index(id, Integer.toString(1), "_mq", "content_s:tes*"); - index(id, Integer.toString(2), "_mq", "content_s:test*"); - index(id, Integer.toString(3), "_mq", "content_s:tex*"); - index(id, Integer.toString(4), "_mq", "content_s:tests*"); + 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); @@ -345,8 +355,8 @@ public void testWildCardQuery() throws Exception { @Test @ShardsFixed(num = 2) public void testDefaultQueryMatchTypeIsNone() throws Exception { - index(id, Integer.toString(0), "_mq", "content_s:\"elevator stairs\""); - index(id, Integer.toString(1), "_mq", "content_s:\"something else\""); + 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); @@ -375,23 +385,27 @@ public void testDefaultQueryMatchTypeIsNone() throws Exception { @Test @ShardsFixed(num = 2) public void testMultiDocHighlightMatchType() throws Exception { - index(id, Integer.toString(0), "_mq", "content0_offset_s:\"elevator stairs\""); + index( + id, + Integer.toString(0), + MonitorFields.MONITOR_QUERY, + "content0_offset_s:\"elevator stairs\""); index( id, Integer.toString(1), - "_mq", + MonitorFields.MONITOR_QUERY, "content0_offset_sds:highlights && content0_offset_sds:field && content0_offset_s:elevator"); index( id, Integer.toString(2), - "_mq", + MonitorFields.MONITOR_QUERY, "content0_offset_sds:ignore && content0_offset_sds:field && content0_offset_s:elevator"); index( id, Integer.toString(3), - "_mq", + MonitorFields.MONITOR_QUERY, "content0_offset_sds:highlights && content0_offset_sds:ignore && content0_offset_s:elevator"); - index(id, Integer.toString(4), "_mq", "content0_offset_s:elevator"); + index(id, Integer.toString(4), MonitorFields.MONITOR_QUERY, "content0_offset_s:elevator"); commit(); handle.clear(); handle.put("responseHeader", SKIP); @@ -442,16 +456,16 @@ public void testMultiDocHighlightMatchType() throws Exception { @Test public void testHighlightMatchType() throws Exception { - index(id, Integer.toString(0), "_mq", "content0_s:\"elevator stairs\""); + index(id, Integer.toString(0), MonitorFields.MONITOR_QUERY, "content0_s:\"elevator stairs\""); index( id, Integer.toString(1), - "_mq", + MonitorFields.MONITOR_QUERY, "content0_sds:highlights || content0_sds:field || content0_s:elevator"); index( id, Integer.toString(2), - "_mq", + MonitorFields.MONITOR_QUERY, "content0_sds:ignore && content0_sds:field && content0_s:elevator"); commit(); handle.clear(); @@ -502,7 +516,7 @@ public void testDeleteByQueryId() throws Exception { index( id, Integer.toString(0), - "_mq", + MonitorFields.MONITOR_QUERY, "{!xmlparser}elevatorlift"); commit(); handle.clear(); diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java index 98f23fdc1744..d7902a3717ef 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java @@ -25,6 +25,7 @@ import java.util.List; import java.util.Map; import java.util.stream.IntStream; +import org.apache.lucene.monitor.MonitorFields; import org.apache.solr.client.solrj.response.QueryResponse; import org.apache.solr.common.params.CommonParams; import org.junit.BeforeClass; @@ -46,7 +47,11 @@ public void manySegmentsQuery() throws Exception { .forEach( i -> { try { - index(id, Integer.toString(i), "_mq", "content_s:\"elevator stairs\""); + index( + id, + Integer.toString(i), + MonitorFields.MONITOR_QUERY, + "content_s:\"elevator stairs\""); } catch (Exception e) { throw new IllegalStateException(e); } @@ -86,7 +91,7 @@ public void manySegmentsQuery() throws Exception { .forEach( i -> { try { - index(id, Integer.toString(i), "_mq", "content_s:\"x y\""); + index(id, Integer.toString(i), MonitorFields.MONITOR_QUERY, "content_s:\"x y\""); } catch (Exception e) { throw new IllegalStateException(e); } @@ -117,7 +122,7 @@ public void coexistWithRegularDocumentsTest() throws Exception { "________________________________monitor_alias_content_s_0", "some more unremarkable content"); commit(); - index(id, "2", "_mq", "content_s:test"); + index(id, "2", MonitorFields.MONITOR_QUERY, "content_s:test"); commit(); handle.clear(); handle.put("responseHeader", SKIP); @@ -142,10 +147,10 @@ public void coexistWithRegularDocumentsTest() throws Exception { @Test @SuppressWarnings("unchecked") public void multiPassPresearcherTest() throws Exception { - index(id, "0", "_mq", "content0_s:\"elevator stairs and escalator\""); - index(id, "1", "_mq", "content0_s:\"elevator test\""); - index(id, "2", "_mq", "content0_s:\"stairs test\""); - index(id, "3", "_mq", "content0_s:\"elevator stairs\""); + index(id, "0", MonitorFields.MONITOR_QUERY, "content0_s:\"elevator stairs and escalator\""); + index(id, "1", MonitorFields.MONITOR_QUERY, "content0_s:\"elevator test\""); + index(id, "2", MonitorFields.MONITOR_QUERY, "content0_s:\"stairs test\""); + index(id, "3", MonitorFields.MONITOR_QUERY, "content0_s:\"elevator stairs\""); commit(); handle.clear(); handle.put("responseHeader", SKIP); diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java index a36f4ed77e01..e9e37f535508 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java @@ -19,6 +19,7 @@ package org.apache.solr.monitor; +import org.apache.lucene.monitor.MonitorFields; import org.junit.BeforeClass; import org.junit.Test; @@ -32,7 +33,10 @@ public static void beforeSuperClass() { @Test public void indexBigQueryTest() throws Exception { index( - id, Integer.toString(0), "_mq", "{!xmlparser}" + read("/monitor/BigDisjunctionQuery.xml")); + id, + Integer.toString(0), + MonitorFields.MONITOR_QUERY, + "{!xmlparser}" + read("/monitor/BigDisjunctionQuery.xml")); commit(); } } From a2419ff9133d8337c27a1cb2cc62bffebb7c05ea Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Wed, 24 Apr 2024 17:32:12 -0400 Subject: [PATCH 25/85] validate MonitorFields.RESERVED_MONITOR_FIELDS in schema --- .../solr/monitor/AliasingPresearcher.java | 4 ++++ .../update/MonitorUpdateProcessorFactory.java | 18 ++++++++++++++++++ 2 files changed, 22 insertions(+) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java index db6476345ef5..4db6bbcc374c 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java @@ -64,6 +64,10 @@ public Document indexQuery(Query query, Map metadata) { return alias(document); } + public String getPrefix() { + return prefix; + } + private Document alias(Document in) { Document out = new Document(); for (var field : in) { diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java index a47cf72c7c5b..e05f369ebd91 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java @@ -19,8 +19,10 @@ package org.apache.solr.monitor.update; +import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.monitor.Presearcher; import org.apache.solr.core.SolrCore; +import org.apache.solr.monitor.AliasingPresearcher; import org.apache.solr.monitor.search.ReverseQueryParserPlugin; import org.apache.solr.request.SolrQueryRequest; import org.apache.solr.response.SolrQueryResponse; @@ -44,5 +46,21 @@ public void inform(SolrCore core) { presearcher = ((ReverseQueryParserPlugin) core.getQueryPlugin(ReverseQueryParserPlugin.NAME)) .getPresearcher(); + var schema = core.getLatestSchema(); + if (presearcher instanceof AliasingPresearcher) { + var fieldType = + schema.getDynamicFieldType(((AliasingPresearcher) presearcher).getPrefix() + "*"); + if (!fieldType.isTokenized()) { + throw new IllegalStateException("presearcher dynamic field type needs to be tokenized."); + } + } + + for (String fieldName : MonitorFields.RESERVED_MONITOR_FIELDS) { + var field = schema.getFieldOrNull(fieldName); + if (field == null) { + throw new IllegalStateException( + fieldName + " needs to be defined in schema for saved search to work."); + } + } } } From 0fde7ef2a57200105c276dcc547e5de7f73dfd28 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 26 Apr 2024 20:23:25 -0400 Subject: [PATCH 26/85] stricter validations of required fields --- .../org/apache/lucene/monitor/MonitorFields.java | 3 +++ .../apache/solr/monitor/MonitorDataValues.java | 6 ++++-- .../update/MonitorUpdateProcessorFactory.java | 15 +++++++++++---- .../solr/collection1/schema-aliasing.xml | 2 +- .../solr/collection1/schema-stored-mq.xml | 2 +- .../src/test-files/solr/collection1/schema.xml | 2 +- 6 files changed, 21 insertions(+), 9 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java index 52fc69f74c52..67c2a20d29cd 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java @@ -32,4 +32,7 @@ public class MonitorFields { public static final Set RESERVED_MONITOR_FIELDS = Set.of(QUERY_ID, CACHE_ID, MONITOR_QUERY, PAYLOAD, VERSION, ANYTOKEN_FIELD); + + public static final Set REQUIRED_MONITOR_FIELDS = + Set.of(QUERY_ID, CACHE_ID, MONITOR_QUERY, ANYTOKEN_FIELD); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java index 7e7a286e0513..dfe397327bf0 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java @@ -79,7 +79,9 @@ public String getPayload() throws IOException { } public long getVersion() throws IOException { - versionIt.advanceExact(currentDoc); - return versionIt.longValue(); + if (versionIt != null && versionIt.advanceExact(currentDoc)) { + return versionIt.longValue(); + } + return 0; } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java index e05f369ebd91..1a750348cfaf 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java @@ -50,17 +50,24 @@ public void inform(SolrCore core) { if (presearcher instanceof AliasingPresearcher) { var fieldType = schema.getDynamicFieldType(((AliasingPresearcher) presearcher).getPrefix() + "*"); - if (!fieldType.isTokenized()) { - throw new IllegalStateException("presearcher dynamic field type needs to be tokenized."); + if (!fieldType.isTokenized() || !fieldType.isMultiValued()) { + throw new IllegalStateException( + "presearcher-aliased field must be tokenized and multi-valued."); } } - for (String fieldName : MonitorFields.RESERVED_MONITOR_FIELDS) { + for (String fieldName : MonitorFields.REQUIRED_MONITOR_FIELDS) { var field = schema.getFieldOrNull(fieldName); if (field == null) { throw new IllegalStateException( - fieldName + " needs to be defined in schema for saved search to work."); + fieldName + " must be defined in schema for saved search to work."); } } + + var anyTokenField = schema.getField(MonitorFields.ANYTOKEN_FIELD); + if (!anyTokenField.tokenized() || !anyTokenField.multiValued()) { + throw new IllegalStateException( + MonitorFields.ANYTOKEN_FIELD + " field must be tokenized and multi-valued."); + } } } diff --git a/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml b/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml index 36d88e15fb04..fd40216a9ef7 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml @@ -99,7 +99,7 @@ useDocValuesAsStored="true"/> - + \ No newline at end of file diff --git a/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml b/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml index bb0d92faa605..16e4a07eafd7 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml @@ -95,6 +95,6 @@ useDocValuesAsStored="true"/> - + \ No newline at end of file diff --git a/solr/modules/monitor/src/test-files/solr/collection1/schema.xml b/solr/modules/monitor/src/test-files/solr/collection1/schema.xml index 2ff2a10085f0..390ffceb53f9 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/schema.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/schema.xml @@ -97,6 +97,6 @@ useDocValuesAsStored="true"/> - + \ No newline at end of file From 59687544b07b046cdc23ba7a1eefea1466d3ae63 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 26 Apr 2024 20:51:01 -0400 Subject: [PATCH 27/85] narrow scope of __anytokenfield validation --- .../org/apache/lucene/monitor/MonitorFields.java | 2 +- .../update/MonitorUpdateProcessorFactory.java | 12 ++++++++---- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java index 67c2a20d29cd..4a777c312845 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java @@ -34,5 +34,5 @@ public class MonitorFields { Set.of(QUERY_ID, CACHE_ID, MONITOR_QUERY, PAYLOAD, VERSION, ANYTOKEN_FIELD); public static final Set REQUIRED_MONITOR_FIELDS = - Set.of(QUERY_ID, CACHE_ID, MONITOR_QUERY, ANYTOKEN_FIELD); + Set.of(QUERY_ID, CACHE_ID, MONITOR_QUERY); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java index 1a750348cfaf..13cebbc61e0d 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java @@ -21,6 +21,7 @@ import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.monitor.Presearcher; +import org.apache.lucene.monitor.TermFilteredPresearcher; import org.apache.solr.core.SolrCore; import org.apache.solr.monitor.AliasingPresearcher; import org.apache.solr.monitor.search.ReverseQueryParserPlugin; @@ -64,10 +65,13 @@ public void inform(SolrCore core) { } } - var anyTokenField = schema.getField(MonitorFields.ANYTOKEN_FIELD); - if (!anyTokenField.tokenized() || !anyTokenField.multiValued()) { - throw new IllegalStateException( - MonitorFields.ANYTOKEN_FIELD + " field must be tokenized and multi-valued."); + if (presearcher instanceof TermFilteredPresearcher + || presearcher instanceof AliasingPresearcher) { + var anyTokenField = schema.getFieldOrNull(MonitorFields.ANYTOKEN_FIELD); + if (anyTokenField == null || !anyTokenField.tokenized() || !anyTokenField.multiValued()) { + throw new IllegalStateException( + MonitorFields.ANYTOKEN_FIELD + " field must be tokenized and multi-valued."); + } } } } From bb11982b05cfa010002424a181181c8c30ac619a Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 3 May 2024 16:03:23 -0400 Subject: [PATCH 28/85] getBool with default Co-authored-by: Christine Poerschke --- .../org/apache/solr/monitor/search/ReverseSearchComponent.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 0bd2901c3fb9..138ebac881ca 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -88,8 +88,7 @@ public void prepare(ResponseBuilder rb) { var req = rb.req; var documentBatch = documentBatch(req); req.getContext().put(DOCUMENT_BATCH_KEY, documentBatch); - var writeToDocListRaw = req.getParams().get(WRITE_TO_DOC_LIST_KEY, "false"); - boolean writeToDocList = Boolean.parseBoolean(writeToDocListRaw); + boolean writeToDocList = req.getParams().getBool(WRITE_TO_DOC_LIST_KEY, false); var matchType = QueryMatchType.fromString(req.getParams().get(QUERY_MATCH_TYPE_KEY)); Map monitorResult = new HashMap<>(); var matcherSink = solrMatcherSinkFactory.build(matchType, documentBatch, monitorResult); From eba6e2d9e8abf7a2837f1e6616c6514943305509 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Sat, 4 May 2024 17:44:07 -0400 Subject: [PATCH 29/85] initialize Presearcher in ReverseSearchComponent + add ReverseSearchHandler + remove ReverseQueryParser(Plugin).java --- .../solr/monitor/AliasingPresearcher.java | 12 +- .../monitor/search/PresearcherFactory.java | 49 ++++--- .../monitor/search/ReverseQueryParser.java | 74 ---------- .../search/ReverseQueryParserPlugin.java | 105 -------------- .../search/ReverseSearchComponent.java | 134 +++++++++++++----- .../monitor/search/ReverseSearchHandler.java | 36 +++++ .../update/MonitorUpdateProcessorFactory.java | 34 +---- .../solr/collection1/schema-aliasing.xml | 2 +- .../solr/collection1/solrconfig-no-cache.xml | 30 +--- .../solr/collection1/solrconfig-parallel.xml | 29 +--- .../solr/collection1/solrconfig.xml | 28 +--- 11 files changed, 194 insertions(+), 339 deletions(-) delete mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParser.java delete mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParserPlugin.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java index 4db6bbcc374c..b349c703fed3 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java @@ -34,12 +34,12 @@ * equivalent. By prefixing fields 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.monitor.ParallelMonitorSolrQueryTest#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. + * schema definition, see {\@link + * org.apache.solr.monitor.ParallelMonitorSolrQueryTest#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 { diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/PresearcherFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/PresearcherFactory.java index df940053ca88..dced3f1cc61d 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/PresearcherFactory.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/PresearcherFactory.java @@ -33,6 +33,14 @@ 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 = + "_________________________________________________monitor_alias_"; + public static final String TERM_FILTERED = TermFilteredPresearcher.class.getSimpleName(); public static final String MULTI_PASS_TERM_FILTERED = MultipassTermFilteredPresearcher.class.getSimpleName(); @@ -102,27 +110,36 @@ private static T constructZeroArgClass( } } - static class PresearcherParameters { - - private final String presearcherType; - private final String termWeightorType; - private final boolean applyFieldNameAlias; - private final int numberOfPasses; - private final float minWeight; - private final String aliasPrefix; - - public PresearcherParameters( - String presearcherType, - String termWeightorType, - boolean applyFieldNameAlias, - int numberOfPasses, - float minWeight, - String aliasPrefix) { + 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/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParser.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParser.java deleted file mode 100644 index c298e3875eb1..000000000000 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParser.java +++ /dev/null @@ -1,74 +0,0 @@ -/* - * - * * 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.monitor.search; - -import static org.apache.solr.monitor.MonitorConstants.DOCUMENT_BATCH_KEY; -import static org.apache.solr.monitor.MonitorConstants.SOLR_MONITOR_CACHE_NAME; - -import java.util.function.BiPredicate; -import org.apache.lucene.index.LeafReader; -import org.apache.lucene.monitor.DocumentBatchVisitor; -import org.apache.lucene.monitor.Presearcher; -import org.apache.lucene.search.Query; -import org.apache.lucene.util.BytesRef; -import org.apache.solr.common.params.SolrParams; -import org.apache.solr.monitor.cache.MonitorQueryCache; -import org.apache.solr.request.SolrQueryRequest; -import org.apache.solr.search.QParser; -import org.apache.solr.search.SyntaxError; - -public class ReverseQueryParser extends QParser { - - private final Presearcher presearcher; - - public ReverseQueryParser( - String qstr, - SolrParams localParams, - SolrParams params, - SolrQueryRequest req, - Presearcher presearcher) { - super(qstr, localParams, params, req); - this.presearcher = presearcher; - } - - @Override - public Query parse() throws SyntaxError { - var obj = req.getContext().get(DOCUMENT_BATCH_KEY); - if (!(obj instanceof DocumentBatchVisitor)) { - throw new SyntaxError(DOCUMENT_BATCH_KEY + " is absent or of unexpected type: " + obj); - } - var documentBatch = (DocumentBatchVisitor) obj; - LeafReader queryIndexReader = documentBatch.get(); - return presearcher.buildQuery(queryIndexReader, getTermAcceptor()); - } - - private BiPredicate getTermAcceptor() { - var searcher = req.getSearcher(); - MonitorQueryCache cache = (MonitorQueryCache) searcher.getCache(SOLR_MONITOR_CACHE_NAME); - if (cache == null) { - return ReverseQueryParser::allTermAcceptor; - } - return cache::acceptTerm; - } - - private static boolean allTermAcceptor(String __, BytesRef ___) { - return true; - } -} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParserPlugin.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParserPlugin.java deleted file mode 100644 index bc0eb2010bc1..000000000000 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseQueryParserPlugin.java +++ /dev/null @@ -1,105 +0,0 @@ -/* - * - * * 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.monitor.search; - -import static org.apache.solr.monitor.search.PresearcherFactory.PresearcherParameters; - -import java.io.IOException; -import java.util.Optional; -import org.apache.lucene.monitor.Presearcher; -import org.apache.lucene.util.ResourceLoader; -import org.apache.lucene.util.ResourceLoaderAware; -import org.apache.solr.common.params.SolrParams; -import org.apache.solr.common.util.NamedList; -import org.apache.solr.request.SolrQueryRequest; -import org.apache.solr.search.QParser; -import org.apache.solr.search.QParserPlugin; - -public class ReverseQueryParserPlugin extends QParserPlugin implements ResourceLoaderAware { - - public static final String NAME = "reverse"; - - // 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. - private static final String DEFAULT_ALIAS_PREFIX = - "________________________________monitor_alias_"; - - private Presearcher presearcher; - private PresearcherParameters presearcherParameters; - - @Override - public QParser createParser( - String qstr, SolrParams localParams, SolrParams params, SolrQueryRequest req) { - return new ReverseQueryParser(qstr, localParams, params, req, presearcher); - } - - @Override - public void close() throws IOException { - super.close(); - } - - @Override - public void init(NamedList args) { - super.init(args); - String presearcherType = (String) args.get("presearcherType"); - String termWeightorType = (String) args.get("termWeightorType"); - boolean applyFieldNameAlias = - resolveProperty(args, "applyFieldNameAlias", Boolean.class, false); - int numberOfPasses = resolveProperty(args, "numberOfPasses", Integer.class, 0); - float minWeight = resolveProperty(args, "minWeight", Float.class, 0f); - String aliasPrefix = - Optional.ofNullable((String) args.get("aliasPrefix")).orElse(DEFAULT_ALIAS_PREFIX); - presearcherParameters = - new PresearcherParameters( - presearcherType, - termWeightorType, - applyFieldNameAlias, - numberOfPasses, - minWeight, - aliasPrefix); - } - - // TODO is there a better pattern for this? NamedList::get(String key, T default) can't be called - // on NamedList - @SuppressWarnings("unchecked") - private T resolveProperty( - NamedList args, String propertyName, Class clazz, T defaultVal) { - Object obj = args.get(propertyName); - if (obj == null) { - return defaultVal; - } - if (clazz.isInstance(obj)) { - return (T) obj; - } - throw new IllegalArgumentException(propertyName + " must be a " + clazz.getSimpleName()); - } - - @Override - public void inform(ResourceLoader loader) throws IOException { - presearcher = PresearcherFactory.build(loader, presearcherParameters); - } - - public Presearcher getPresearcher() { - return presearcher; - } -} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 138ebac881ca..5158efcbaee7 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -19,27 +19,33 @@ package org.apache.solr.monitor.search; -import static org.apache.solr.monitor.MonitorConstants.DOCUMENT_BATCH_KEY; import static org.apache.solr.monitor.MonitorConstants.MONITOR_DOCUMENTS_KEY; import static org.apache.solr.monitor.MonitorConstants.MONITOR_OUTPUT_KEY; import static org.apache.solr.monitor.MonitorConstants.QUERY_MATCH_TYPE_KEY; import static org.apache.solr.monitor.MonitorConstants.REVERSE_SEARCH_PARAM_NAME; import static org.apache.solr.monitor.MonitorConstants.SOLR_MONITOR_CACHE_NAME; import static org.apache.solr.monitor.MonitorConstants.WRITE_TO_DOC_LIST_KEY; +import static org.apache.solr.monitor.search.PresearcherFactory.DEFAULT_ALIAS_PREFIX; import static org.apache.solr.monitor.search.QueryMatchResponseCodec.mergeResponses; -import java.io.IOException; import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Optional; import java.util.concurrent.ExecutorService; +import java.util.function.BiPredicate; import java.util.stream.Collectors; import org.apache.lucene.document.Document; import org.apache.lucene.monitor.DocumentBatchVisitor; +import org.apache.lucene.monitor.MonitorFields; +import org.apache.lucene.monitor.Presearcher; +import org.apache.lucene.monitor.TermFilteredPresearcher; import org.apache.lucene.search.MatchAllDocsQuery; import org.apache.lucene.search.Query; +import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.NamedThreadFactory; import org.apache.solr.common.SolrException; import org.apache.solr.common.SolrException.ErrorCode; @@ -47,37 +53,42 @@ import org.apache.solr.common.util.NamedList; import org.apache.solr.core.CloseHook; import org.apache.solr.core.SolrCore; +import org.apache.solr.handler.component.QueryComponent; import org.apache.solr.handler.component.ResponseBuilder; -import org.apache.solr.handler.component.SearchComponent; import org.apache.solr.handler.component.ShardRequest; import org.apache.solr.handler.loader.JsonLoader; +import org.apache.solr.monitor.AliasingPresearcher; import org.apache.solr.monitor.SolrMonitorQueryDecoder; import org.apache.solr.monitor.cache.MonitorQueryCache; import org.apache.solr.monitor.cache.SharedMonitorCache; import org.apache.solr.request.SolrQueryRequest; -import org.apache.solr.search.QParser; -import org.apache.solr.search.SyntaxError; +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 SearchComponent implements SolrCoreAware { +public class ReverseSearchComponent extends QueryComponent implements SolrCoreAware { + public static final String COMPONENT_NAME = "reverseSearch"; private static final String MATCHER_THREAD_COUNT_KEY = "threadCount"; + private Presearcher presearcher; private SolrMatcherSinkFactory solrMatcherSinkFactory = new SolrMatcherSinkFactory(); - private ExecutorService executor; + private PresearcherFactory.PresearcherParameters presearcherParameters; @Override public void init(NamedList args) { super.init(args); - Object threadCount = args.get(MATCHER_THREAD_COUNT_KEY); + Object threadCount = args.remove(MATCHER_THREAD_COUNT_KEY); if (threadCount instanceof Integer) { executor = ExecutorUtil.newMDCAwareFixedThreadPool( (Integer) threadCount, new NamedThreadFactory("monitor-matcher")); solrMatcherSinkFactory = new SolrMatcherSinkFactory(executor); } + presearcherParameters = new PresearcherFactory.PresearcherParameters(); + SolrPluginUtils.invokeSetters(presearcherParameters, args); } @Override @@ -97,28 +108,23 @@ public void prepare(ResponseBuilder rb) { ErrorCode.BAD_REQUEST, "writeToDocList is not supported for parallel matcher. Consider adding more shards/cores instead of parallel matcher."); } - try { - Query preFilterQuery = - QParser.getParser("{!" + ReverseQueryParserPlugin.NAME + "}", req).parse(); - List mutableFilters = - Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); - rb.setQuery(new MatchAllDocsQuery()); - mutableFilters.add(preFilterQuery); - var searcher = req.getSearcher(); - MonitorQueryCache solrMonitorCache = - (SharedMonitorCache) searcher.getCache(SOLR_MONITOR_CACHE_NAME); - SolrMonitorQueryDecoder queryDecoder = SolrMonitorQueryDecoder.fromCore(req.getCore()); - mutableFilters.add( - new MonitorPostFilter( - new SolrMonitorQueryCollector.CollectorContext( - solrMonitorCache, queryDecoder, matcherSink, writeToDocList, matchType))); - rb.setFilters(mutableFilters); - rb.rsp.add(QUERY_MATCH_TYPE_KEY, matchType.name()); - if (matchType != QueryMatchType.NONE) { - rb.rsp.add(MONITOR_OUTPUT_KEY, monitorResult); - } - } catch (SyntaxError e) { - throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "Syntax error in query: ", e); + Query preFilterQuery = presearcher.buildQuery(documentBatch.get(), getTermAcceptor(rb.req)); + List mutableFilters = + Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); + rb.setQuery(new MatchAllDocsQuery()); + mutableFilters.add(preFilterQuery); + var searcher = req.getSearcher(); + MonitorQueryCache solrMonitorCache = + (SharedMonitorCache) searcher.getCache(SOLR_MONITOR_CACHE_NAME); + SolrMonitorQueryDecoder queryDecoder = SolrMonitorQueryDecoder.fromCore(req.getCore()); + mutableFilters.add( + new MonitorPostFilter( + new SolrMonitorQueryCollector.CollectorContext( + solrMonitorCache, queryDecoder, matcherSink, writeToDocList, matchType))); + rb.setFilters(mutableFilters); + rb.rsp.add(QUERY_MATCH_TYPE_KEY, matchType.name()); + if (matchType != QueryMatchType.NONE) { + rb.rsp.add(MONITOR_OUTPUT_KEY, monitorResult); } } @@ -147,11 +153,6 @@ private DocumentBatchVisitor documentBatch(SolrQueryRequest req) { return DocumentBatchVisitor.of(req.getSchema().getIndexAnalyzer(), luceneDocs); } - @Override - public void process(ResponseBuilder rb) throws IOException { - /* no-op */ - } - @Override public void handleResponses(ResponseBuilder rb, ShardRequest sreq) { if (skipReverseSearch(rb) || (sreq.purpose & ShardRequest.PURPOSE_GET_TOP_IDS) == 0) { @@ -187,5 +188,68 @@ public void preClose(SolrCore core) { ExecutorUtil.shutdownAndAwaitTermination(executor); } }); + 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_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(MonitorFields.ANYTOKEN_FIELD); + if (anyTokenField == null || !anyTokenField.tokenized() || !anyTokenField.multiValued()) { + throw new IllegalStateException( + MonitorFields.ANYTOKEN_FIELD + " field must be tokenized and multi-valued."); + } + } + } + + public Presearcher getPresearcher() { + return presearcher; + } + + private BiPredicate getTermAcceptor(SolrQueryRequest req) { + var searcher = req.getSearcher(); + MonitorQueryCache cache = (MonitorQueryCache) searcher.getCache(SOLR_MONITOR_CACHE_NAME); + if (cache == null) { + return (__, ___) -> true; + } + return cache::acceptTerm; } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java new file mode 100644 index 000000000000..64e8827fb4c0 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/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.monitor.search; + +import java.util.ArrayList; +import java.util.List; +import org.apache.solr.handler.component.QueryComponent; +import org.apache.solr.handler.component.SearchHandler; + +public class ReverseSearchHandler extends SearchHandler { + + @Override + protected List getDefaultComponents() { + ArrayList names = new ArrayList<>(2); + names.add(QueryComponent.COMPONENT_NAME); + names.add(ReverseSearchComponent.COMPONENT_NAME); + return names; + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java index 13cebbc61e0d..03a22ca9750e 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java @@ -19,12 +19,9 @@ package org.apache.solr.monitor.update; -import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.monitor.Presearcher; -import org.apache.lucene.monitor.TermFilteredPresearcher; import org.apache.solr.core.SolrCore; -import org.apache.solr.monitor.AliasingPresearcher; -import org.apache.solr.monitor.search.ReverseQueryParserPlugin; +import org.apache.solr.monitor.search.ReverseSearchComponent; import org.apache.solr.request.SolrQueryRequest; import org.apache.solr.response.SolrQueryResponse; import org.apache.solr.update.processor.UpdateRequestProcessor; @@ -45,33 +42,8 @@ public UpdateRequestProcessor getInstance( @Override public void inform(SolrCore core) { presearcher = - ((ReverseQueryParserPlugin) core.getQueryPlugin(ReverseQueryParserPlugin.NAME)) + ((ReverseSearchComponent) + core.getSearchComponents().get(ReverseSearchComponent.COMPONENT_NAME)) .getPresearcher(); - var schema = core.getLatestSchema(); - if (presearcher instanceof AliasingPresearcher) { - var fieldType = - schema.getDynamicFieldType(((AliasingPresearcher) presearcher).getPrefix() + "*"); - if (!fieldType.isTokenized() || !fieldType.isMultiValued()) { - throw new IllegalStateException( - "presearcher-aliased field must be tokenized and multi-valued."); - } - } - - for (String fieldName : MonitorFields.REQUIRED_MONITOR_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(MonitorFields.ANYTOKEN_FIELD); - if (anyTokenField == null || !anyTokenField.tokenized() || !anyTokenField.multiValued()) { - throw new IllegalStateException( - MonitorFields.ANYTOKEN_FIELD + " field must be tokenized and multi-valued."); - } - } } } diff --git a/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml b/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml index fd40216a9ef7..9579084ed407 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml @@ -100,6 +100,6 @@ - + \ No newline at end of file diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml index a3a9682c74f0..437caac4bbf5 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml @@ -81,24 +81,8 @@ - - - explicit - 10 - id - - - reverseSearch - - - - - explicit - json - true - id - - + + @@ -124,7 +108,10 @@ + class="org.apache.solr.monitor.search.ReverseSearchComponent"> + TermFilteredPresearcher + true + text_general @@ -178,9 +165,4 @@ - - TermFilteredPresearcher - true - diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml index 5c59fe82924b..6fc2c4a34009 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml @@ -86,24 +86,8 @@ - - - explicit - 10 - id - - - reverseSearch - - - - - explicit - json - true - id - - + + @@ -131,6 +115,9 @@ 16 + MultipassTermFilteredPresearcher + true + 4 text_general @@ -185,10 +172,4 @@ - - MultipassTermFilteredPresearcher - true - 4 - diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml index 321e85228c41..30253813ed69 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml @@ -87,24 +87,8 @@ - - - explicit - 10 - id - - - reverseSearch - - - - - explicit - json - true - id - - + + @@ -130,7 +114,9 @@ + class="org.apache.solr.monitor.search.ReverseSearchComponent"> + TermFilteredPresearcher + text_general @@ -184,8 +170,4 @@ - - TermFilteredPresearcher - From d3ccf0c21282eb54538d83305ff3792457a2c039 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Sat, 4 May 2024 17:50:09 -0400 Subject: [PATCH 30/85] remove unused constant --- .../src/java/org/apache/solr/monitor/MonitorConstants.java | 1 - .../org/apache/solr/monitor/search/ReverseSearchComponent.java | 1 - 2 files changed, 2 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java index 91fc87af4861..b7593939ade8 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java @@ -26,7 +26,6 @@ public class MonitorConstants { private MonitorConstants() {} public static final String REVERSE_SEARCH_PARAM_NAME = "reverseSearch"; - public static final String DOCUMENT_BATCH_KEY = "documentBatch"; public static final String SOLR_MONITOR_CACHE_NAME = "solrMonitorCache"; public static final String MONITOR_DOCUMENTS_KEY = "monitorDocuments"; public static final String MONITOR_DOCUMENT_KEY = "monitorDocument"; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 5158efcbaee7..a9c63634e6f4 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -98,7 +98,6 @@ public void prepare(ResponseBuilder rb) { } var req = rb.req; var documentBatch = documentBatch(req); - req.getContext().put(DOCUMENT_BATCH_KEY, documentBatch); boolean writeToDocList = req.getParams().getBool(WRITE_TO_DOC_LIST_KEY, false); var matchType = QueryMatchType.fromString(req.getParams().get(QUERY_MATCH_TYPE_KEY)); Map monitorResult = new HashMap<>(); From e12ec6fa880c67b31d2078c5f410ed517e98f530 Mon Sep 17 00:00:00 2001 From: Christine Poerschke Date: Fri, 10 May 2024 12:44:27 +0100 Subject: [PATCH 31/85] make SolrMonitorCache name optionally configurable --- .../org/apache/solr/monitor/MonitorConstants.java | 1 - .../solr/monitor/search/ReverseSearchComponent.java | 13 ++++++++++--- .../solr/collection1/solrconfig-parallel.xml | 3 ++- 3 files changed, 12 insertions(+), 5 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java index b7593939ade8..ed61720c7ecf 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java @@ -26,7 +26,6 @@ public class MonitorConstants { private MonitorConstants() {} public static final String REVERSE_SEARCH_PARAM_NAME = "reverseSearch"; - public static final String SOLR_MONITOR_CACHE_NAME = "solrMonitorCache"; public static final String MONITOR_DOCUMENTS_KEY = "monitorDocuments"; public static final String MONITOR_DOCUMENT_KEY = "monitorDocument"; public static final String MONITOR_QUERIES_KEY = "queries"; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index a9c63634e6f4..c516a11c82ea 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -23,7 +23,6 @@ import static org.apache.solr.monitor.MonitorConstants.MONITOR_OUTPUT_KEY; import static org.apache.solr.monitor.MonitorConstants.QUERY_MATCH_TYPE_KEY; import static org.apache.solr.monitor.MonitorConstants.REVERSE_SEARCH_PARAM_NAME; -import static org.apache.solr.monitor.MonitorConstants.SOLR_MONITOR_CACHE_NAME; import static org.apache.solr.monitor.MonitorConstants.WRITE_TO_DOC_LIST_KEY; import static org.apache.solr.monitor.search.PresearcherFactory.DEFAULT_ALIAS_PREFIX; import static org.apache.solr.monitor.search.QueryMatchResponseCodec.mergeResponses; @@ -72,6 +71,10 @@ public class ReverseSearchComponent extends QueryComponent implements SolrCoreAw public static final String COMPONENT_NAME = "reverseSearch"; private static final String MATCHER_THREAD_COUNT_KEY = "threadCount"; + private static final String SOLR_MONITOR_CACHE_NAME_KEY = "solrMonitorCacheName"; + private static final String SOLR_MONITOR_CACHE_NAME_DEFAULT = "solrMonitorCache"; + private String solrMonitorCacheName = SOLR_MONITOR_CACHE_NAME_DEFAULT; + private Presearcher presearcher; private SolrMatcherSinkFactory solrMatcherSinkFactory = new SolrMatcherSinkFactory(); private ExecutorService executor; @@ -80,6 +83,10 @@ public class ReverseSearchComponent extends QueryComponent implements SolrCoreAw @Override public void init(NamedList args) { super.init(args); + Object solrMonitorCacheName = args.remove(SOLR_MONITOR_CACHE_NAME_KEY); + if (solrMonitorCacheName != null) { + this.solrMonitorCacheName = (String) solrMonitorCacheName; + } Object threadCount = args.remove(MATCHER_THREAD_COUNT_KEY); if (threadCount instanceof Integer) { executor = @@ -114,7 +121,7 @@ public void prepare(ResponseBuilder rb) { mutableFilters.add(preFilterQuery); var searcher = req.getSearcher(); MonitorQueryCache solrMonitorCache = - (SharedMonitorCache) searcher.getCache(SOLR_MONITOR_CACHE_NAME); + (SharedMonitorCache) searcher.getCache(this.solrMonitorCacheName); SolrMonitorQueryDecoder queryDecoder = SolrMonitorQueryDecoder.fromCore(req.getCore()); mutableFilters.add( new MonitorPostFilter( @@ -245,7 +252,7 @@ public Presearcher getPresearcher() { private BiPredicate getTermAcceptor(SolrQueryRequest req) { var searcher = req.getSearcher(); - MonitorQueryCache cache = (MonitorQueryCache) searcher.getCache(SOLR_MONITOR_CACHE_NAME); + MonitorQueryCache cache = (MonitorQueryCache) searcher.getCache(this.solrMonitorCacheName); if (cache == null) { return (__, ___) -> true; } diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml index 6fc2c4a34009..6fb6ede409f7 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml @@ -65,7 +65,7 @@ initialSize="0" autowarmCount="10" regenerator="solr.NoOpRegenerator"/> - + mySolrMonitorCache 16 MultipassTermFilteredPresearcher true From 6d4986cd20fd91729e146d1f1bd409269c64bb10 Mon Sep 17 00:00:00 2001 From: Christine Poerschke Date: Fri, 10 May 2024 15:40:52 +0100 Subject: [PATCH 32/85] [exploratory] turn MonitorConstants.QUERY_DECOMPOSER into ReverseSearchComponent.queryDecomposer --- .../solr/monitor/SolrMonitorQueryDecoder.java | 35 ++++++++++++------- .../monitor/cache/SharedMonitorCache.java | 11 +++--- .../SharedMonitorCacheLatestRegenerator.java | 2 +- .../search/ReverseSearchComponent.java | 9 ++++- .../search/SolrMonitorQueryCollector.java | 5 +-- .../update/MonitorUpdateProcessorFactory.java | 13 ++++--- .../update/MonitorUpdateRequestProcessor.java | 11 ++++-- 7 files changed, 54 insertions(+), 32 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java index 4e1045391c0c..1542fe6d1b21 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java @@ -23,22 +23,31 @@ import java.util.Map; import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.monitor.MonitorQuery; +import org.apache.lucene.monitor.QueryDecomposer; import org.apache.solr.core.SolrCore; +import org.apache.solr.monitor.search.ReverseSearchComponent; -public interface SolrMonitorQueryDecoder { +public class SolrMonitorQueryDecoder { - MonitorQuery decode(MonitorDataValues monitorDataValues) throws IOException; + private final SolrCore core; + public final QueryDecomposer queryDecomposer; - static SolrMonitorQueryDecoder fromCore(SolrCore core) { - return monitorDataValues -> { - String id = monitorDataValues.getQueryId(); - String queryStr = monitorDataValues.getMq(); - var query = SimpleQueryParser.parse(queryStr, core); - String payload = monitorDataValues.getPayload(); - if (payload == null) { - return new MonitorQuery(id, query, queryStr, Map.of()); - } - return new MonitorQuery(id, query, queryStr, Map.of(MonitorFields.PAYLOAD, payload)); - }; + public SolrMonitorQueryDecoder(SolrCore core) { + this.core = core; + ReverseSearchComponent rsc = + (ReverseSearchComponent) + core.getSearchComponents().get(ReverseSearchComponent.COMPONENT_NAME); + this.queryDecomposer = rsc.getQueryDecomposer(); + } + + public MonitorQuery decode(MonitorDataValues monitorDataValues) throws IOException { + String id = monitorDataValues.getQueryId(); + String queryStr = monitorDataValues.getMq(); + var query = SimpleQueryParser.parse(queryStr, core); + String payload = monitorDataValues.getPayload(); + if (payload == null) { + return new MonitorQuery(id, query, queryStr, Map.of()); + } + return new MonitorQuery(id, query, queryStr, Map.of(MonitorFields.PAYLOAD, payload)); } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java index 106467ea262d..a6428d9ef1ec 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java @@ -32,6 +32,7 @@ import java.util.function.BiPredicate; import org.apache.lucene.monitor.MonitorQuery; import org.apache.lucene.monitor.QCEVisitor; +import org.apache.lucene.monitor.QueryDecomposer; import org.apache.lucene.monitor.QueryTermFilterVisitor; import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.RamUsageEstimator; @@ -39,7 +40,6 @@ import org.apache.solr.common.SolrException.ErrorCode; import org.apache.solr.metrics.MetricsMap; import org.apache.solr.metrics.SolrMetricsContext; -import org.apache.solr.monitor.MonitorConstants; import org.apache.solr.monitor.MonitorDataValues; import org.apache.solr.monitor.SolrMonitorQueryDecoder; import org.apache.solr.search.CacheRegenerator; @@ -81,7 +81,8 @@ public VersionedQueryCacheEntry computeIfStale( return mqCacheMap() .compute( dataValues.getCacheId(), - (cacheId, prevEntry) -> compute(cacheId, prevEntry, dataValues, decoder::decode)); + (cacheId, prevEntry) -> + compute(cacheId, prevEntry, dataValues, decoder::decode, decoder.queryDecomposer)); } @Override @@ -277,13 +278,13 @@ private VersionedQueryCacheEntry compute( String cacheId, VersionedQueryCacheEntry prevEntry, MonitorDataValues dataValues, - IOFunction decoder) { + IOFunction decoder, + QueryDecomposer decomposer) { try { var version = dataValues.getVersion(); if (prevEntry == null || version > prevEntry.version) { var monitorQuery = decoder.apply(dataValues); - QCEVisitor component = - QCEVisitor.getComponent(monitorQuery, MonitorConstants.QUERY_DECOMPOSER, cacheId); + QCEVisitor component = QCEVisitor.getComponent(monitorQuery, decomposer, cacheId); currentStats.updateAndGet(CurrentStats::miss); return new VersionedQueryCacheEntry(component, version); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java index ec02c427476f..7d9c6172dd00 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java @@ -57,7 +57,7 @@ public boolean regenerateItem( .search(versionRangeQuery(cache), batchSize) .scoreDocs; int batchesRemaining = cache.getInitialSize() / batchSize - 1; - SolrMonitorQueryDecoder decoder = SolrMonitorQueryDecoder.fromCore(searcher.getCore()); + SolrMonitorQueryDecoder decoder = new SolrMonitorQueryDecoder(searcher.getCore()); MonitorDataValues dataValues = new MonitorDataValues(); while (topDocs.length > 0 && batchesRemaining > 0) { int docIndex = 0; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index c516a11c82ea..0ea2df5513ae 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -41,6 +41,7 @@ import org.apache.lucene.monitor.DocumentBatchVisitor; import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.monitor.Presearcher; +import org.apache.lucene.monitor.QueryDecomposer; import org.apache.lucene.monitor.TermFilteredPresearcher; import org.apache.lucene.search.MatchAllDocsQuery; import org.apache.lucene.search.Query; @@ -75,6 +76,7 @@ public class ReverseSearchComponent extends QueryComponent implements SolrCoreAw private static final String SOLR_MONITOR_CACHE_NAME_DEFAULT = "solrMonitorCache"; private String solrMonitorCacheName = SOLR_MONITOR_CACHE_NAME_DEFAULT; + private QueryDecomposer queryDecomposer; private Presearcher presearcher; private SolrMatcherSinkFactory solrMatcherSinkFactory = new SolrMatcherSinkFactory(); private ExecutorService executor; @@ -122,7 +124,7 @@ public void prepare(ResponseBuilder rb) { var searcher = req.getSearcher(); MonitorQueryCache solrMonitorCache = (SharedMonitorCache) searcher.getCache(this.solrMonitorCacheName); - SolrMonitorQueryDecoder queryDecoder = SolrMonitorQueryDecoder.fromCore(req.getCore()); + SolrMonitorQueryDecoder queryDecoder = new SolrMonitorQueryDecoder(req.getCore()); mutableFilters.add( new MonitorPostFilter( new SolrMonitorQueryCollector.CollectorContext( @@ -194,6 +196,7 @@ public void preClose(SolrCore core) { ExecutorUtil.shutdownAndAwaitTermination(executor); } }); + queryDecomposer = new QueryDecomposer(); presearcher = PresearcherFactory.build(core.getResourceLoader(), presearcherParameters); var schema = core.getLatestSchema(); if (presearcher instanceof AliasingPresearcher) { @@ -246,6 +249,10 @@ public void preClose(SolrCore core) { } } + public QueryDecomposer getQueryDecomposer() { + return queryDecomposer; + } + public Presearcher getPresearcher() { return presearcher; } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java index 409919744741..111d1ff20ceb 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java @@ -24,7 +24,6 @@ import org.apache.lucene.monitor.QCEVisitor; import org.apache.lucene.search.ConstantScoreQuery; import org.apache.lucene.search.ScoreMode; -import org.apache.solr.monitor.MonitorConstants; import org.apache.solr.monitor.MonitorDataValues; import org.apache.solr.monitor.SolrMonitorQueryDecoder; import org.apache.solr.monitor.cache.MonitorQueryCache; @@ -70,9 +69,7 @@ private QCEVisitor getEntry(MonitorDataValues dataValues) throws IOException { : monitorQueryCache.computeIfStale(dataValues, queryDecoder); return (versionedEntry == null || versionedEntry.version != dataValues.getVersion()) ? QCEVisitor.getComponent( - queryDecoder.decode(dataValues), - MonitorConstants.QUERY_DECOMPOSER, - dataValues.getCacheId()) + queryDecoder.decode(dataValues), queryDecoder.queryDecomposer, dataValues.getCacheId()) : versionedEntry.entry; } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java index 03a22ca9750e..0f4f7e825d3d 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java @@ -20,6 +20,7 @@ package org.apache.solr.monitor.update; import org.apache.lucene.monitor.Presearcher; +import org.apache.lucene.monitor.QueryDecomposer; import org.apache.solr.core.SolrCore; import org.apache.solr.monitor.search.ReverseSearchComponent; import org.apache.solr.request.SolrQueryRequest; @@ -31,19 +32,21 @@ public class MonitorUpdateProcessorFactory extends UpdateRequestProcessorFactory implements SolrCoreAware { + private QueryDecomposer queryDecomposer; private Presearcher presearcher; @Override public UpdateRequestProcessor getInstance( SolrQueryRequest req, SolrQueryResponse rsp, UpdateRequestProcessor next) { - return new MonitorUpdateRequestProcessor(next, req.getCore(), presearcher); + return new MonitorUpdateRequestProcessor(next, req.getCore(), queryDecomposer, presearcher); } @Override public void inform(SolrCore core) { - presearcher = - ((ReverseSearchComponent) - core.getSearchComponents().get(ReverseSearchComponent.COMPONENT_NAME)) - .getPresearcher(); + ReverseSearchComponent rsc = + (ReverseSearchComponent) + core.getSearchComponents().get(ReverseSearchComponent.COMPONENT_NAME); + presearcher = rsc.getPresearcher(); + queryDecomposer = rsc.getQueryDecomposer(); } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java index af2cbd72d948..6ff38c839bac 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java @@ -40,12 +40,12 @@ import org.apache.lucene.monitor.MonitorQuery; import org.apache.lucene.monitor.Presearcher; import org.apache.lucene.monitor.QCEVisitor; +import org.apache.lucene.monitor.QueryDecomposer; import org.apache.lucene.util.BytesRef; import org.apache.solr.common.SolrException; import org.apache.solr.common.SolrInputDocument; import org.apache.solr.common.util.JavaBinCodec; import org.apache.solr.core.SolrCore; -import org.apache.solr.monitor.MonitorConstants; import org.apache.solr.monitor.MonitorSchemaFields; import org.apache.solr.monitor.SimpleQueryParser; import org.apache.solr.schema.IndexSchema; @@ -57,14 +57,19 @@ public class MonitorUpdateRequestProcessor extends UpdateRequestProcessor { private final SolrCore core; private final IndexSchema indexSchema; + private final QueryDecomposer queryDecomposer; private final Presearcher presearcher; private final MonitorSchemaFields monitorSchemaFields; public MonitorUpdateRequestProcessor( - UpdateRequestProcessor next, SolrCore core, Presearcher presearcher) { + UpdateRequestProcessor next, + SolrCore core, + QueryDecomposer queryDecomposer, + Presearcher presearcher) { super(next); this.core = core; this.indexSchema = core.getLatestSchema(); + this.queryDecomposer = queryDecomposer; this.presearcher = presearcher; this.monitorSchemaFields = new MonitorSchemaFields(indexSchema); } @@ -135,7 +140,7 @@ private void copyFirstChildToParent(SolrInputDocument parent, SolrInputDocument } private Stream decompose(MonitorQuery monitorQuery, String payload) { - return QCEVisitor.decompose(monitorQuery, MonitorConstants.QUERY_DECOMPOSER).stream() + return QCEVisitor.decompose(monitorQuery, queryDecomposer).stream() .map( qce -> { Document doc = From 3aae9f06c14cf6b73a4945db423da70c29ce32c2 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 10 May 2024 19:17:00 -0400 Subject: [PATCH 33/85] remove REVERSE_SEARCH_PARAM_NAME flag in favor of dedicated path --- .../apache/solr/monitor/MonitorConstants.java | 1 - .../search/ReverseSearchComponent.java | 10 +--- .../solr/collection1/solrconfig-no-cache.xml | 59 ++++--------------- .../solr/collection1/solrconfig-parallel.xml | 58 ++++-------------- .../solr/collection1/solrconfig.xml | 59 ++++--------------- .../solr/monitor/MonitorSolrQueryTest.java | 49 ++++++++------- .../monitor/ParallelMonitorSolrQueryTest.java | 13 ++-- 7 files changed, 70 insertions(+), 179 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java index ed61720c7ecf..a7f2b1697c48 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java @@ -25,7 +25,6 @@ public class MonitorConstants { private MonitorConstants() {} - public static final String REVERSE_SEARCH_PARAM_NAME = "reverseSearch"; public static final String MONITOR_DOCUMENTS_KEY = "monitorDocuments"; public static final String MONITOR_DOCUMENT_KEY = "monitorDocument"; public static final String MONITOR_QUERIES_KEY = "queries"; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index c516a11c82ea..d21291635bd5 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -22,7 +22,6 @@ import static org.apache.solr.monitor.MonitorConstants.MONITOR_DOCUMENTS_KEY; import static org.apache.solr.monitor.MonitorConstants.MONITOR_OUTPUT_KEY; import static org.apache.solr.monitor.MonitorConstants.QUERY_MATCH_TYPE_KEY; -import static org.apache.solr.monitor.MonitorConstants.REVERSE_SEARCH_PARAM_NAME; import static org.apache.solr.monitor.MonitorConstants.WRITE_TO_DOC_LIST_KEY; import static org.apache.solr.monitor.search.PresearcherFactory.DEFAULT_ALIAS_PREFIX; import static org.apache.solr.monitor.search.QueryMatchResponseCodec.mergeResponses; @@ -100,9 +99,6 @@ public void init(NamedList args) { @Override public void prepare(ResponseBuilder rb) { - if (skipReverseSearch(rb)) { - return; - } var req = rb.req; var documentBatch = documentBatch(req); boolean writeToDocList = req.getParams().getBool(WRITE_TO_DOC_LIST_KEY, false); @@ -161,7 +157,7 @@ private DocumentBatchVisitor documentBatch(SolrQueryRequest req) { @Override public void handleResponses(ResponseBuilder rb, ShardRequest sreq) { - if (skipReverseSearch(rb) || (sreq.purpose & ShardRequest.PURPOSE_GET_TOP_IDS) == 0) { + if ((sreq.purpose & ShardRequest.PURPOSE_GET_TOP_IDS) == 0) { return; } var responses = @@ -181,10 +177,6 @@ public String getDescription() { return "Component that integrates with lucene monitor for reverse search."; } - private static boolean skipReverseSearch(ResponseBuilder rb) { - return !rb.req.getParams().getBool(REVERSE_SEARCH_PARAM_NAME, false); - } - @Override public void inform(SolrCore core) { core.addCloseHook( diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml index 437caac4bbf5..cf862e8cb620 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml @@ -81,12 +81,21 @@ - - - + + explicit + json + true + id + + + + + explicit + json + true + id @@ -112,42 +121,6 @@ TermFilteredPresearcher true - - text_general - - - - - true - - - tvComponent - - - - - - true - false - - - terms - tvComponent - - - - string - - - - - explicit - - - elevator - - @@ -158,11 +131,5 @@ text/plain; charset=UTF-8 - - ${velocity.template.base.dir:} - ${velocity.solr.resource.loader.enabled:true} - ${velocity.params.resource.loader.enabled:false} - - diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml index 6fb6ede409f7..4cac6076c13b 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml @@ -86,12 +86,21 @@ - - - + + explicit + json + true + id + + + + + explicit + json + true + id @@ -120,42 +129,7 @@ true 4 - - text_general - - - - - true - - - tvComponent - - - - - - true - false - - - terms - tvComponent - - - - string - - - - explicit - - - elevator - - @@ -166,11 +140,5 @@ text/plain; charset=UTF-8 - - ${velocity.template.base.dir:} - ${velocity.solr.resource.loader.enabled:true} - ${velocity.params.resource.loader.enabled:false} - - diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml index 30253813ed69..3f7c187f7999 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml @@ -87,12 +87,21 @@ - - - + + explicit + json + true + id + + + + + explicit + json + true + id @@ -117,42 +126,6 @@ class="org.apache.solr.monitor.search.ReverseSearchComponent"> TermFilteredPresearcher - - text_general - - - - - true - - - tvComponent - - - - - - true - false - - - terms - tvComponent - - - - string - - - - - explicit - - - elevator - - @@ -163,11 +136,5 @@ text/plain; charset=UTF-8 - - ${velocity.template.base.dir:} - ${velocity.solr.resource.loader.enabled:true} - ${velocity.params.resource.loader.enabled:false} - - diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java index d2a72012dbb2..196dcf4512a9 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java @@ -23,7 +23,6 @@ import static org.apache.solr.monitor.MonitorConstants.MONITOR_OUTPUT_KEY; import static org.apache.solr.monitor.MonitorConstants.MONITOR_QUERIES_KEY; import static org.apache.solr.monitor.MonitorConstants.QUERY_MATCH_TYPE_KEY; -import static org.apache.solr.monitor.MonitorConstants.REVERSE_SEARCH_PARAM_NAME; import static org.apache.solr.monitor.MonitorConstants.WRITE_TO_DOC_LIST_KEY; import java.io.IOException; @@ -79,8 +78,8 @@ public void testMonitorQuery() throws Exception { MonitorFields.QUERY_ID + " desc", CommonParams.JSON, read("/monitor/multi-doc-batch.json"), - REVERSE_SEARCH_PARAM_NAME, - true, + CommonParams.QT, + "/reverseSearch", QUERY_MATCH_TYPE_KEY, "simple" }; @@ -110,8 +109,8 @@ public void testMonitorQuery() throws Exception { id + " desc", CommonParams.JSON, read("/monitor/multi-doc-batch.json"), - REVERSE_SEARCH_PARAM_NAME, - true, + CommonParams.QT, + "/reverseSearch", WRITE_TO_DOC_LIST_KEY, supportsWriteToDocList(), QUERY_MATCH_TYPE_KEY, @@ -154,8 +153,8 @@ public void testNoDocListInResponse() throws Exception { MonitorFields.QUERY_ID + " desc", CommonParams.JSON, read("/monitor/multi-doc-batch.json"), - REVERSE_SEARCH_PARAM_NAME, - true, + CommonParams.QT, + "/reverseSearch", WRITE_TO_DOC_LIST_KEY, false, QUERY_MATCH_TYPE_KEY, @@ -184,8 +183,8 @@ public void testDefaultParser() throws Exception { id + " desc", CommonParams.JSON, read("/monitor/multi-doc-batch.json"), - REVERSE_SEARCH_PARAM_NAME, - true, + CommonParams.QT, + "/reverseSearch", WRITE_TO_DOC_LIST_KEY, supportsWriteToDocList(), QUERY_MATCH_TYPE_KEY, @@ -222,8 +221,8 @@ public void testDisjunctionQuery() throws Exception { id + " desc", CommonParams.JSON, read("/monitor/single-doc-batch.json"), - REVERSE_SEARCH_PARAM_NAME, - true, + CommonParams.QT, + "/reverseSearch", WRITE_TO_DOC_LIST_KEY, supportsWriteToDocList(), QUERY_MATCH_TYPE_KEY, @@ -256,8 +255,8 @@ public void testNoDanglingDecomposition() throws Exception { id + " desc", CommonParams.JSON, read("/monitor/dangling-test-single-doc-batch.json"), - REVERSE_SEARCH_PARAM_NAME, - true, + CommonParams.QT, + "/reverseSearch", WRITE_TO_DOC_LIST_KEY, supportsWriteToDocList(), QUERY_MATCH_TYPE_KEY, @@ -304,8 +303,8 @@ public void testNotQuery() throws Exception { id + " desc", CommonParams.JSON, read("/monitor/single-doc-batch.json"), - REVERSE_SEARCH_PARAM_NAME, - true, + CommonParams.QT, + "/reverseSearch", WRITE_TO_DOC_LIST_KEY, supportsWriteToDocList(), QUERY_MATCH_TYPE_KEY, @@ -335,8 +334,8 @@ public void testWildCardQuery() throws Exception { id + " desc", CommonParams.JSON, read("/monitor/multi-doc-batch.json"), - REVERSE_SEARCH_PARAM_NAME, - true, + CommonParams.QT, + "/reverseSearch", WRITE_TO_DOC_LIST_KEY, supportsWriteToDocList(), QUERY_MATCH_TYPE_KEY, @@ -368,8 +367,8 @@ public void testDefaultQueryMatchTypeIsNone() throws Exception { id + " desc", CommonParams.JSON, read("/monitor/multi-doc-batch.json"), - REVERSE_SEARCH_PARAM_NAME, - true, + CommonParams.QT, + "/reverseSearch", WRITE_TO_DOC_LIST_KEY, supportsWriteToDocList() }; @@ -417,8 +416,8 @@ public void testMultiDocHighlightMatchType() throws Exception { id + " desc", CommonParams.JSON, read("/monitor/multi-doc-batch-multi-valued.json"), - REVERSE_SEARCH_PARAM_NAME, - true, + CommonParams.QT, + "/reverseSearch", QUERY_MATCH_TYPE_KEY, "highlights", WRITE_TO_DOC_LIST_KEY, @@ -478,8 +477,8 @@ public void testHighlightMatchType() throws Exception { id + " desc", CommonParams.JSON, read("/monitor/single-doc-batch-multi-valued.json"), - REVERSE_SEARCH_PARAM_NAME, - true, + CommonParams.QT, + "/reverseSearch", QUERY_MATCH_TYPE_KEY, "highlights", WRITE_TO_DOC_LIST_KEY, @@ -529,8 +528,8 @@ public void testDeleteByQueryId() throws Exception { id + " desc", CommonParams.JSON, read("/monitor/dangling-test-single-doc-batch.json"), - REVERSE_SEARCH_PARAM_NAME, - true, + CommonParams.QT, + "/reverseSearch", WRITE_TO_DOC_LIST_KEY, supportsWriteToDocList(), QUERY_MATCH_TYPE_KEY, diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java index d7902a3717ef..e238ff91e061 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java @@ -20,7 +20,6 @@ package org.apache.solr.monitor; import static org.apache.solr.monitor.MonitorConstants.QUERY_MATCH_TYPE_KEY; -import static org.apache.solr.monitor.MonitorConstants.REVERSE_SEARCH_PARAM_NAME; import java.util.List; import java.util.Map; @@ -67,8 +66,8 @@ public void manySegmentsQuery() throws Exception { id + " desc", CommonParams.JSON, read("/monitor/multi-doc-batch.json"), - REVERSE_SEARCH_PARAM_NAME, - true, + CommonParams.QT, + "/reverseSearch", QUERY_MATCH_TYPE_KEY, "simple" }; @@ -134,8 +133,8 @@ public void coexistWithRegularDocumentsTest() throws Exception { id + " desc", CommonParams.JSON, read("/monitor/multi-doc-batch.json"), - REVERSE_SEARCH_PARAM_NAME, - true, + CommonParams.QT, + "/reverseSearch", QUERY_MATCH_TYPE_KEY, "simple" }; @@ -162,8 +161,8 @@ public void multiPassPresearcherTest() throws Exception { id + " desc", CommonParams.JSON, read("/monitor/single-doc-batch.json"), - REVERSE_SEARCH_PARAM_NAME, - true, + CommonParams.QT, + "/reverseSearch", QUERY_MATCH_TYPE_KEY, "simple" }; From 0915ce18a4b43810465d9eb5008faf979a53cbf7 Mon Sep 17 00:00:00 2001 From: Christine Poerschke Date: Tue, 14 May 2024 18:05:47 +0100 Subject: [PATCH 34/85] move getComponent from QCEVisitor to SolrMonitorQueryDecoder as suggested by @kotman12 --- .../java/org/apache/lucene/monitor/QCEVisitor.java | 10 ---------- .../apache/solr/monitor/SolrMonitorQueryDecoder.java | 12 +++++++++++- .../solr/monitor/cache/SharedMonitorCache.java | 12 ++++-------- .../monitor/search/SolrMonitorQueryCollector.java | 3 +-- 4 files changed, 16 insertions(+), 21 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/QCEVisitor.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/QCEVisitor.java index a1ff2733b71e..963ce8d27b31 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/QCEVisitor.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/QCEVisitor.java @@ -40,16 +40,6 @@ public static List decompose(MonitorQuery mq, QueryDecomposer decomp return cacheEntries; } - public static QCEVisitor getComponent( - MonitorQuery mq, QueryDecomposer decomposer, String cacheId) { - for (QCEVisitor qce : QCEVisitor.decompose(mq, decomposer)) { - if (qce.getCacheId().equals(cacheId)) { - return qce; - } - } - throw new IllegalArgumentException("Corrupt monitorQuery value in index"); - } - public Query getMatchQuery() { return qce.matchQuery; } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java index 1542fe6d1b21..77b749466b53 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java @@ -23,6 +23,7 @@ import java.util.Map; import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.monitor.MonitorQuery; +import org.apache.lucene.monitor.QCEVisitor; import org.apache.lucene.monitor.QueryDecomposer; import org.apache.solr.core.SolrCore; import org.apache.solr.monitor.search.ReverseSearchComponent; @@ -30,7 +31,7 @@ public class SolrMonitorQueryDecoder { private final SolrCore core; - public final QueryDecomposer queryDecomposer; + private final QueryDecomposer queryDecomposer; public SolrMonitorQueryDecoder(SolrCore core) { this.core = core; @@ -50,4 +51,13 @@ public MonitorQuery decode(MonitorDataValues monitorDataValues) throws IOExcepti } return new MonitorQuery(id, query, queryStr, Map.of(MonitorFields.PAYLOAD, payload)); } + + public QCEVisitor getComponent(MonitorQuery mq, String cacheId) { + for (QCEVisitor qce : QCEVisitor.decompose(mq, queryDecomposer)) { + if (qce.getCacheId().equals(cacheId)) { + return qce; + } + } + throw new IllegalArgumentException("Corrupt monitorQuery value in index"); + } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java index a6428d9ef1ec..c66444ba3ab8 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java @@ -30,9 +30,7 @@ import java.util.Map; import java.util.concurrent.atomic.AtomicReference; import java.util.function.BiPredicate; -import org.apache.lucene.monitor.MonitorQuery; import org.apache.lucene.monitor.QCEVisitor; -import org.apache.lucene.monitor.QueryDecomposer; import org.apache.lucene.monitor.QueryTermFilterVisitor; import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.RamUsageEstimator; @@ -81,8 +79,7 @@ public VersionedQueryCacheEntry computeIfStale( return mqCacheMap() .compute( dataValues.getCacheId(), - (cacheId, prevEntry) -> - compute(cacheId, prevEntry, dataValues, decoder::decode, decoder.queryDecomposer)); + (cacheId, prevEntry) -> compute(cacheId, prevEntry, dataValues, decoder)); } @Override @@ -278,13 +275,12 @@ private VersionedQueryCacheEntry compute( String cacheId, VersionedQueryCacheEntry prevEntry, MonitorDataValues dataValues, - IOFunction decoder, - QueryDecomposer decomposer) { + SolrMonitorQueryDecoder decoder) { try { var version = dataValues.getVersion(); if (prevEntry == null || version > prevEntry.version) { - var monitorQuery = decoder.apply(dataValues); - QCEVisitor component = QCEVisitor.getComponent(monitorQuery, decomposer, cacheId); + var monitorQuery = decoder.decode(dataValues); + QCEVisitor component = decoder.getComponent(monitorQuery, cacheId); currentStats.updateAndGet(CurrentStats::miss); return new VersionedQueryCacheEntry(component, version); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java index 111d1ff20ceb..a0b181c01b27 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java @@ -68,8 +68,7 @@ private QCEVisitor getEntry(MonitorDataValues dataValues) throws IOException { ? null : monitorQueryCache.computeIfStale(dataValues, queryDecoder); return (versionedEntry == null || versionedEntry.version != dataValues.getVersion()) - ? QCEVisitor.getComponent( - queryDecoder.decode(dataValues), queryDecoder.queryDecomposer, dataValues.getCacheId()) + ? queryDecoder.getComponent(queryDecoder.decode(dataValues), dataValues.getCacheId()) : versionedEntry.entry; } From e6e25a54abdfdbf754802d80e9235b390a070d63 Mon Sep 17 00:00:00 2001 From: Christine Poerschke Date: Tue, 14 May 2024 18:17:23 +0100 Subject: [PATCH 35/85] avoid queryDecoder.getComponent(queryDecoder.decode(...), ...) usage pattern --- .../org/apache/solr/monitor/SolrMonitorQueryDecoder.java | 6 +++--- .../org/apache/solr/monitor/cache/SharedMonitorCache.java | 3 +-- .../solr/monitor/search/SolrMonitorQueryCollector.java | 2 +- 3 files changed, 5 insertions(+), 6 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java index 77b749466b53..4239d1b41894 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java @@ -41,7 +41,7 @@ public SolrMonitorQueryDecoder(SolrCore core) { this.queryDecomposer = rsc.getQueryDecomposer(); } - public MonitorQuery decode(MonitorDataValues monitorDataValues) throws IOException { + private MonitorQuery decode(MonitorDataValues monitorDataValues) throws IOException { String id = monitorDataValues.getQueryId(); String queryStr = monitorDataValues.getMq(); var query = SimpleQueryParser.parse(queryStr, core); @@ -52,8 +52,8 @@ public MonitorQuery decode(MonitorDataValues monitorDataValues) throws IOExcepti return new MonitorQuery(id, query, queryStr, Map.of(MonitorFields.PAYLOAD, payload)); } - public QCEVisitor getComponent(MonitorQuery mq, String cacheId) { - for (QCEVisitor qce : QCEVisitor.decompose(mq, queryDecomposer)) { + public QCEVisitor getComponent(MonitorDataValues dataValues, String cacheId) throws IOException { + for (QCEVisitor qce : QCEVisitor.decompose(decode(dataValues), queryDecomposer)) { if (qce.getCacheId().equals(cacheId)) { return qce; } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java index c66444ba3ab8..f010b8dfa548 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java @@ -279,8 +279,7 @@ private VersionedQueryCacheEntry compute( try { var version = dataValues.getVersion(); if (prevEntry == null || version > prevEntry.version) { - var monitorQuery = decoder.decode(dataValues); - QCEVisitor component = decoder.getComponent(monitorQuery, cacheId); + QCEVisitor component = decoder.getComponent(dataValues, cacheId); currentStats.updateAndGet(CurrentStats::miss); return new VersionedQueryCacheEntry(component, version); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java index a0b181c01b27..f4a8583ac859 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java @@ -68,7 +68,7 @@ private QCEVisitor getEntry(MonitorDataValues dataValues) throws IOException { ? null : monitorQueryCache.computeIfStale(dataValues, queryDecoder); return (versionedEntry == null || versionedEntry.version != dataValues.getVersion()) - ? queryDecoder.getComponent(queryDecoder.decode(dataValues), dataValues.getCacheId()) + ? queryDecoder.getComponent(dataValues, dataValues.getCacheId()) : versionedEntry.entry; } From e1365ad14b301b515fc65065b3125534c3fed2f2 Mon Sep 17 00:00:00 2001 From: Christine Poerschke Date: Wed, 15 May 2024 11:47:13 +0100 Subject: [PATCH 36/85] remove now no-longer-used MonitorConstants.QUERY_DECOMPOSER --- .../src/java/org/apache/solr/monitor/MonitorConstants.java | 3 --- 1 file changed, 3 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java index a7f2b1697c48..be775c2f2963 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java @@ -19,8 +19,6 @@ package org.apache.solr.monitor; -import org.apache.lucene.monitor.QueryDecomposer; - public class MonitorConstants { private MonitorConstants() {} @@ -33,5 +31,4 @@ private MonitorConstants() {} public static final String MONITOR_OUTPUT_KEY = "monitor"; public static final String WRITE_TO_DOC_LIST_KEY = "writeToDocList"; public static final String HITS_KEY = "hits"; - public static final QueryDecomposer QUERY_DECOMPOSER = new QueryDecomposer(); } From 5b37a6a870b6be6a9f605ef048b23f41134f00b8 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Tue, 4 Jun 2024 14:39:36 -0400 Subject: [PATCH 37/85] coexistWithRegularDocumentsTest with multiple update chains --- .../solr/collection1/schema-aliasing.xml | 3 +- .../solrconfig-not-distributed.xml | 148 ++++++++++++++++++ .../solr/monitor/MonitorSolrQueryTest.java | 4 +- .../monitor/NonDistributedMonitorTest.java | 96 ++++++++++++ .../monitor/ParallelMonitorSolrQueryTest.java | 31 ---- 5 files changed, 246 insertions(+), 36 deletions(-) create mode 100644 solr/modules/monitor/src/test-files/solr/collection1/solrconfig-not-distributed.xml create mode 100644 solr/modules/monitor/src/test/org/apache/solr/monitor/NonDistributedMonitorTest.java diff --git a/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml b/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml index 9579084ed407..661923bac3fa 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml @@ -27,8 +27,7 @@ - - + diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-not-distributed.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-not-distributed.xml new file mode 100644 index 000000000000..78b2930273d1 --- /dev/null +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-not-distributed.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/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java index 196dcf4512a9..c7ef039baff6 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java @@ -64,9 +64,7 @@ public void testMonitorQuery() throws Exception { id, Integer.toString(7), MonitorFields.MONITOR_QUERY, - "content_s:something", - MonitorFields.PAYLOAD, - "some metadata"); + "content_s:something"); commit(); handle.clear(); handle.put("responseHeader", SKIP); diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/NonDistributedMonitorTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/NonDistributedMonitorTest.java new file mode 100644 index 000000000000..ddc4a2ee9272 --- /dev/null +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/NonDistributedMonitorTest.java @@ -0,0 +1,96 @@ +/* + * + * * 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.monitor; + +import org.apache.lucene.monitor.MonitorFields; +import org.apache.solr.SolrTestCaseJ4; +import org.apache.solr.common.params.CommonParams; +import org.junit.BeforeClass; +import org.junit.Test; + +import java.net.URL; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; + +import static org.apache.solr.monitor.MonitorConstants.QUERY_MATCH_TYPE_KEY; +import static org.apache.solr.monitor.MonitorConstants.WRITE_TO_DOC_LIST_KEY; + +public class NonDistributedMonitorTest extends SolrTestCaseJ4 { + + @BeforeClass + public static void beforeTests() throws Exception { + initCore("solrconfig-not-distributed.xml", "schema-aliasing.xml"); + } + + @Test + public void coexistWithRegularDocumentsTest() throws Exception { + String regularChain = "regular-ole-document"; + addDoc(adoc("id", "0", "content_s", "some unremarkable content"), regularChain); + addDoc(commit(), regularChain); + String monitorChain = "monitor"; + addDoc(adoc("id", "1", MonitorFields.MONITOR_QUERY, "content_s:test"), monitorChain); + addDoc(commit(), monitorChain); + URL url = getClass().getResource("/monitor/multi-doc-batch.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", + QUERY_MATCH_TYPE_KEY, + "simple", + WRITE_TO_DOC_LIST_KEY, + "true" + }; + + assertQ(req(params), "//*[@numFound='1']"); + } + + @Test + public void queryStringIdTest() throws Exception { + String monitorChain = "monitor"; + 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-doc-batch.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", + QUERY_MATCH_TYPE_KEY, + "simple", + WRITE_TO_DOC_LIST_KEY, + "true" + }; + + assertQ(req(params), "//*[@numFound='2']"); + } +} diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java index e238ff91e061..c0fc490caab5 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java @@ -112,37 +112,6 @@ public void manySegmentsQuery() throws Exception { .size()); } - @Test - public void coexistWithRegularDocumentsTest() throws Exception { - index(id, "0", "content_s", "some unremarkable content"); - index( - id, - "1", - "________________________________monitor_alias_content_s_0", - "some more unremarkable content"); - commit(); - index(id, "2", MonitorFields.MONITOR_QUERY, "content_s:test"); - commit(); - handle.clear(); - handle.put("responseHeader", SKIP); - handle.put("response", SKIP); - - Object[] params = - new Object[] { - CommonParams.SORT, - id + " desc", - CommonParams.JSON, - read("/monitor/multi-doc-batch.json"), - CommonParams.QT, - "/reverseSearch", - QUERY_MATCH_TYPE_KEY, - "simple" - }; - - QueryResponse response = query(params); - validate(response, 4, 0, "2"); - } - @Test @SuppressWarnings("unchecked") public void multiPassPresearcherTest() throws Exception { From e4af381e48c0fca1b35ebad3157dd2b4092d8d60 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Tue, 4 Jun 2024 15:54:03 -0400 Subject: [PATCH 38/85] remove payload and additional field support --- .../apache/lucene/monitor/MonitorFields.java | 5 - .../solr/monitor/AliasingPresearcher.java | 2 +- .../solr/monitor/MonitorDataValues.java | 15 +- .../solr/monitor/MonitorSchemaFields.java | 6 - .../solr/monitor/SolrMonitorQueryDecoder.java | 7 +- .../SharedMonitorCacheLatestRegenerator.java | 4 +- .../update/MonitorUpdateRequestProcessor.java | 92 ++++++------- .../solr/monitor/MonitorSolrQueryTest.java | 6 +- .../monitor/NonDistributedMonitorTest.java | 128 ++++++++++-------- 9 files changed, 114 insertions(+), 151 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java index 4a777c312845..4e0f918b0ffd 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java @@ -26,13 +26,8 @@ public 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 String PAYLOAD = QueryIndex.FIELDS.mq + "_payload_"; - public static final String VERSION = "_version_"; public static final String ANYTOKEN_FIELD = TermFilteredPresearcher.ANYTOKEN_FIELD; - public static final Set RESERVED_MONITOR_FIELDS = - Set.of(QUERY_ID, CACHE_ID, MONITOR_QUERY, PAYLOAD, VERSION, ANYTOKEN_FIELD); - public static final Set REQUIRED_MONITOR_FIELDS = Set.of(QUERY_ID, CACHE_ID, MONITOR_QUERY); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java index b349c703fed3..9f2ea775d242 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java @@ -71,7 +71,7 @@ public String getPrefix() { private Document alias(Document in) { Document out = new Document(); for (var field : in) { - if (!MonitorFields.RESERVED_MONITOR_FIELDS.contains(field.name()) + if (!MonitorFields.ANYTOKEN_FIELD.equals(field.name()) && field instanceof Field && ((Field) field).tokenStreamValue() != null) { out.add( diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java index dfe397327bf0..b75073ce91ee 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java @@ -26,13 +26,13 @@ import org.apache.lucene.index.SortedDocValues; import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.search.DocIdSetIterator; +import org.apache.solr.common.params.CommonParams; public class MonitorDataValues { private SortedDocValues queryIdIt; private SortedDocValues cacheIdIt; private SortedDocValues mqIt; - private SortedDocValues payloadIt; private NumericDocValues versionIt; private int currentDoc = DocIdSetIterator.NO_MORE_DOCS; private LeafReader reader; @@ -42,8 +42,7 @@ public void update(LeafReaderContext context) throws IOException { cacheIdIt = reader.getSortedDocValues(MonitorFields.CACHE_ID); queryIdIt = reader.getSortedDocValues(MonitorFields.QUERY_ID); mqIt = reader.getSortedDocValues(MonitorFields.MONITOR_QUERY); - payloadIt = reader.getSortedDocValues(MonitorFields.PAYLOAD); - versionIt = reader.getNumericDocValues(MonitorFields.VERSION); + versionIt = reader.getNumericDocValues(CommonParams.VERSION_FIELD); currentDoc = DocIdSetIterator.NO_MORE_DOCS; } @@ -68,16 +67,6 @@ public String getMq() throws IOException { return reader.document(currentDoc).get(MonitorFields.MONITOR_QUERY); } - public String getPayload() throws IOException { - if (payloadIt != null) { - if (payloadIt.advanceExact(currentDoc)) { - return payloadIt.lookupOrd(payloadIt.ordValue()).utf8ToString(); - } - return null; - } - return reader.document(currentDoc).get(MonitorFields.PAYLOAD); - } - public long getVersion() throws IOException { if (versionIt != null && versionIt.advanceExact(currentDoc)) { return versionIt.longValue(); diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorSchemaFields.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorSchemaFields.java index a4683a0fc880..9807f114e16e 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorSchemaFields.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorSchemaFields.java @@ -28,13 +28,11 @@ public class MonitorSchemaFields { private final SchemaField cacheId; private final SchemaField queryId; private final SchemaField monitorQuery; - private final SchemaField payload; public MonitorSchemaFields(IndexSchema indexSchema) { this.cacheId = indexSchema.getField(MonitorFields.CACHE_ID); this.queryId = indexSchema.getField(MonitorFields.QUERY_ID); this.monitorQuery = indexSchema.getField(MonitorFields.MONITOR_QUERY); - this.payload = indexSchema.getField(MonitorFields.PAYLOAD); } public SchemaField getCacheId() { @@ -48,8 +46,4 @@ public SchemaField getQueryId() { public SchemaField getMonitorQuery() { return monitorQuery; } - - public SchemaField getPayload() { - return payload; - } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java index 4239d1b41894..7f6b99f97ede 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java @@ -21,7 +21,6 @@ import java.io.IOException; import java.util.Map; -import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.monitor.MonitorQuery; import org.apache.lucene.monitor.QCEVisitor; import org.apache.lucene.monitor.QueryDecomposer; @@ -45,11 +44,7 @@ private MonitorQuery decode(MonitorDataValues monitorDataValues) throws IOExcept String id = monitorDataValues.getQueryId(); String queryStr = monitorDataValues.getMq(); var query = SimpleQueryParser.parse(queryStr, core); - String payload = monitorDataValues.getPayload(); - if (payload == null) { - return new MonitorQuery(id, query, queryStr, Map.of()); - } - return new MonitorQuery(id, query, queryStr, Map.of(MonitorFields.PAYLOAD, payload)); + return new MonitorQuery(id, query, queryStr, Map.of()); } public QCEVisitor getComponent(MonitorDataValues dataValues, String cacheId) throws IOException { diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java index 7d9c6172dd00..08e585c0fb97 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java @@ -22,9 +22,9 @@ import java.io.IOException; import org.apache.lucene.document.LongPoint; import org.apache.lucene.index.LeafReaderContext; -import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; +import org.apache.solr.common.params.CommonParams; import org.apache.solr.monitor.MonitorDataValues; import org.apache.solr.monitor.SolrMonitorQueryDecoder; import org.apache.solr.search.CacheRegenerator; @@ -89,6 +89,6 @@ public boolean regenerateItem( private static Query versionRangeQuery(SharedMonitorCache cache) { return LongPoint.newRangeQuery( - MonitorFields.VERSION, cache.versionHighWaterMark, Long.MAX_VALUE); + CommonParams.VERSION_FIELD, cache.versionHighWaterMark, Long.MAX_VALUE); } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java index 6ff38c839bac..e3a0ec8ef0a9 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java @@ -80,53 +80,42 @@ public void processAdd(AddUpdateCommand cmd) throws IOException { var queryId = (String) solrInputDocument.getFieldValue(indexSchema.getUniqueKeyField().getName()); var queryFieldValue = solrInputDocument.getFieldValue(MonitorFields.MONITOR_QUERY); - if (queryFieldValue != null) { - var payload = - Optional.ofNullable(solrInputDocument.getFieldValue(MonitorFields.PAYLOAD)) - .map(Object::toString) - .orElse(null); - 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(monitorQuery -> decompose(monitorQuery, payload)) - .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 -> - solrInputDocument.forEach( - field -> { - if (!MonitorFields.RESERVED_MONITOR_FIELDS.contains(field.getName())) { - child.addField(field.getName(), field.getValue()); - } - })); - solrInputDocument - .getChildDocuments() - .forEach( - child -> - child.setField( - indexSchema.getUniqueKeyField().getName(), - child.getFieldValue(MonitorFields.CACHE_ID))); - } - copyFirstChildToParent(solrInputDocument, firstChild); - } + if (queryFieldValue == null) { + throw new SolrException( + SolrException.ErrorCode.BAD_REQUEST, + MonitorFields.MONITOR_QUERY + " field missing from request."); + } + 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( + indexSchema.getUniqueKeyField().getName(), + child.getFieldValue(MonitorFields.CACHE_ID))); + } + copyFirstChildToParent(solrInputDocument, firstChild); super.processAdd(cmd); } @@ -134,12 +123,12 @@ private void copyFirstChildToParent(SolrInputDocument parent, SolrInputDocument parent.setField( indexSchema.getUniqueKeyField().getName(), firstChild.getFieldValue(MonitorFields.CACHE_ID)); - for (var firstBornInputField : firstChild) { - parent.setField(firstBornInputField.getName(), firstBornInputField.getValue()); + for (var firstChildField : firstChild) { + parent.setField(firstChildField.getName(), firstChildField.getValue()); } } - private Stream decompose(MonitorQuery monitorQuery, String payload) { + private Stream decompose(MonitorQuery monitorQuery) { return QCEVisitor.decompose(monitorQuery, queryDecomposer).stream() .map( qce -> { @@ -149,9 +138,6 @@ private Stream decompose(MonitorQuery monitorQuery, String payload) { doc.add(monitorSchemaFields.getCacheId().createField(qce.getCacheId())); doc.add( monitorSchemaFields.getMonitorQuery().createField(monitorQuery.getQueryString())); - if (payload != null) { - doc.add(monitorSchemaFields.getPayload().createField(payload)); - } return doc; }); } diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java index c7ef039baff6..7a675f09dba4 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java @@ -60,11 +60,7 @@ public void testMonitorQuery() throws Exception { 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"); + index(id, Integer.toString(7), MonitorFields.MONITOR_QUERY, "content_s:something"); commit(); handle.clear(); handle.put("responseHeader", SKIP); diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/NonDistributedMonitorTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/NonDistributedMonitorTest.java index ddc4a2ee9272..22eb0e462bb2 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/NonDistributedMonitorTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/NonDistributedMonitorTest.java @@ -19,78 +19,86 @@ package org.apache.solr.monitor; -import org.apache.lucene.monitor.MonitorFields; -import org.apache.solr.SolrTestCaseJ4; -import org.apache.solr.common.params.CommonParams; -import org.junit.BeforeClass; -import org.junit.Test; +import static org.apache.solr.monitor.MonitorConstants.QUERY_MATCH_TYPE_KEY; +import static org.apache.solr.monitor.MonitorConstants.WRITE_TO_DOC_LIST_KEY; import java.net.URL; import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; - -import static org.apache.solr.monitor.MonitorConstants.QUERY_MATCH_TYPE_KEY; -import static org.apache.solr.monitor.MonitorConstants.WRITE_TO_DOC_LIST_KEY; +import org.apache.lucene.monitor.MonitorFields; +import org.apache.solr.SolrTestCaseJ4; +import org.apache.solr.common.params.CommonParams; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; public class NonDistributedMonitorTest extends SolrTestCaseJ4 { - @BeforeClass - public static void beforeTests() throws Exception { - initCore("solrconfig-not-distributed.xml", "schema-aliasing.xml"); - } + @BeforeClass + public static void beforeTests() throws Exception { + initCore("solrconfig-not-distributed.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); - String monitorChain = "monitor"; - addDoc(adoc("id", "1", MonitorFields.MONITOR_QUERY, "content_s:test"), monitorChain); - addDoc(commit(), monitorChain); - URL url = getClass().getResource("/monitor/multi-doc-batch.json"); - String json = Files.readString(Path.of(url.toURI()), StandardCharsets.UTF_8); + @Test + public void coexistWithRegularDocumentsTest() throws Exception { + String regularChain = "regular-ole-document"; + addDoc(adoc("id", "0", "content_s", "some unremarkable content"), regularChain); + addDoc(commit(), regularChain); + String monitorChain = "monitor"; + addDoc(adoc("id", "1", MonitorFields.MONITOR_QUERY, "content_s:test"), monitorChain); + addDoc(commit(), monitorChain); + URL url = getClass().getResource("/monitor/multi-doc-batch.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", - QUERY_MATCH_TYPE_KEY, - "simple", - WRITE_TO_DOC_LIST_KEY, - "true" - }; + String[] params = + new String[] { + CommonParams.SORT, + "id desc", + CommonParams.JSON, + json, + CommonParams.QT, + "/reverseSearch", + QUERY_MATCH_TYPE_KEY, + "simple", + WRITE_TO_DOC_LIST_KEY, + "true" + }; - assertQ(req(params), "//*[@numFound='1']"); - } + assertQ(req(params), "//*[@numFound='1']"); + } - @Test - public void queryStringIdTest() throws Exception { - String monitorChain = "monitor"; - 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-doc-batch.json"); - String json = Files.readString(Path.of(url.toURI()), StandardCharsets.UTF_8); + @Test + public void queryStringIdTest() throws Exception { + String monitorChain = "monitor"; + 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-doc-batch.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", - QUERY_MATCH_TYPE_KEY, - "simple", - WRITE_TO_DOC_LIST_KEY, - "true" - }; + String[] params = + new String[] { + CommonParams.SORT, + "id desc", + CommonParams.JSON, + json, + CommonParams.QT, + "/reverseSearch", + QUERY_MATCH_TYPE_KEY, + "simple", + WRITE_TO_DOC_LIST_KEY, + "true" + }; - assertQ(req(params), "//*[@numFound='2']"); - } + assertQ(req(params), "//*[@numFound='2']"); + } } From 7be05a337f8a968a21593a5916f420ef6d38d973 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Tue, 4 Jun 2024 17:09:58 -0400 Subject: [PATCH 39/85] validate fields in MonitorUpdateRequestProcessor --- .../apache/lucene/monitor/MonitorFields.java | 2 +- .../search/ReverseSearchComponent.java | 2 +- .../update/MonitorUpdateRequestProcessor.java | 35 ++++++++++++---- .../monitor/NonDistributedMonitorTest.java | 42 +++++++++++++++++++ 4 files changed, 72 insertions(+), 9 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java index 4e0f918b0ffd..3972e28e81a9 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java @@ -28,6 +28,6 @@ public class MonitorFields { public static final String MONITOR_QUERY = QueryIndex.FIELDS.mq + "_"; public static final String ANYTOKEN_FIELD = TermFilteredPresearcher.ANYTOKEN_FIELD; - public static final Set REQUIRED_MONITOR_FIELDS = + public static final Set REQUIRED_MONITOR_SCHEMA_FIELDS = Set.of(QUERY_ID, CACHE_ID, MONITOR_QUERY); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 08c65eb60441..9d9653502453 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -223,7 +223,7 @@ public void preClose(SolrCore core) { } } - for (String fieldName : MonitorFields.REQUIRED_MONITOR_FIELDS) { + for (String fieldName : MonitorFields.REQUIRED_MONITOR_SCHEMA_FIELDS) { var field = schema.getFieldOrNull(fieldName); if (field == null) { throw new IllegalStateException( diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java index e3a0ec8ef0a9..3f2b77151b85 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java @@ -25,6 +25,7 @@ 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; @@ -44,6 +45,7 @@ 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.monitor.MonitorSchemaFields; @@ -60,6 +62,7 @@ public class MonitorUpdateRequestProcessor extends UpdateRequestProcessor { private final QueryDecomposer queryDecomposer; private final Presearcher presearcher; private final MonitorSchemaFields monitorSchemaFields; + private final Set allowedFieldNames; public MonitorUpdateRequestProcessor( UpdateRequestProcessor next, @@ -72,18 +75,39 @@ public MonitorUpdateRequestProcessor( this.queryDecomposer = queryDecomposer; this.presearcher = presearcher; this.monitorSchemaFields = new MonitorSchemaFields(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(); - var queryId = - (String) solrInputDocument.getFieldValue(indexSchema.getUniqueKeyField().getName()); + 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, - MonitorFields.MONITOR_QUERY + " field missing from 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) @@ -110,10 +134,7 @@ public void processAdd(AddUpdateCommand cmd) throws IOException { solrInputDocument .getChildDocuments() .forEach( - child -> - child.setField( - indexSchema.getUniqueKeyField().getName(), - child.getFieldValue(MonitorFields.CACHE_ID))); + child -> child.setField(idFieldName, child.getFieldValue(MonitorFields.CACHE_ID))); } copyFirstChildToParent(solrInputDocument, firstChild); super.processAdd(cmd); diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/NonDistributedMonitorTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/NonDistributedMonitorTest.java index 22eb0e462bb2..e43411fd7522 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/NonDistributedMonitorTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/NonDistributedMonitorTest.java @@ -26,8 +26,10 @@ import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; +import java.util.Locale; import org.apache.lucene.monitor.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; @@ -101,4 +103,44 @@ public void queryStringIdTest() throws Exception { assertQ(req(params), "//*[@numFound='2']"); } + + @Test + public void missingQueryFieldTest() { + String monitorChain = "monitor"; + 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 monitorChain = "monitor"; + 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)); + } } From f2d47be4e7d65215de65158903e1dd332a02b896 Mon Sep 17 00:00:00 2001 From: Christine Poerschke Date: Fri, 14 Jun 2024 18:57:48 +0100 Subject: [PATCH 40/85] start MonitorSolrQueryTest.validateDocList --- .../solr/monitor/MonitorSolrQueryTest.java | 119 +++++++++++------- .../monitor/ParallelMonitorSolrQueryTest.java | 6 +- 2 files changed, 78 insertions(+), 47 deletions(-) diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java index 7a675f09dba4..276cd78e728b 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java @@ -79,9 +79,9 @@ public void testMonitorQuery() throws Exception { }; QueryResponse response = query(params); System.out.println("Response = " + response); - validate(response, 0, List.of("1", "4")); - validate(response, 1, List.of("7")); - validate(response, 2, List.of("5")); + validate(response, 0, List.of("1", "4"), false); + validate(response, 1, List.of("7"), false); + validate(response, 2, List.of("5"), false); assertEquals(0, ((SolrDocumentList) response.getResponse().get("response")).size()); index(id, Integer.toString(5), MonitorFields.MONITOR_QUERY, "other_content_s:\"solr is lame\""); @@ -97,6 +97,7 @@ public void testMonitorQuery() throws Exception { handle.put("responseHeader", SKIP); handle.put("response", SKIP); + final boolean writeToDocList = supportsWriteToDocList(); params = new Object[] { CommonParams.SORT, @@ -106,17 +107,17 @@ public void testMonitorQuery() throws Exception { CommonParams.QT, "/reverseSearch", WRITE_TO_DOC_LIST_KEY, - supportsWriteToDocList(), + writeToDocList, QUERY_MATCH_TYPE_KEY, "simple" }; response = query(params); System.out.println("Response = " + response); - validate(response, 0, 0, "2"); - validate(response, 0, 1, "4"); - validate(response, 1, 0, "7"); - validate(response, 2, 0, "6"); - if (supportsWriteToDocList()) { + validate(response, 0, 0, "2", writeToDocList); + validate(response, 0, 1, "4", writeToDocList); + validate(response, 1, 0, "7", writeToDocList); + validate(response, 2, 0, "6", writeToDocList); + if (writeToDocList) { assertEquals(4, ((SolrDocumentList) response.getResponse().get("response")).size()); } } @@ -141,6 +142,7 @@ public void testNoDocListInResponse() throws Exception { handle.put("responseHeader", SKIP); handle.put("response", SKIP); + final boolean writeToDocList = false; Object[] params = new Object[] { CommonParams.SORT, @@ -150,15 +152,15 @@ public void testNoDocListInResponse() throws Exception { CommonParams.QT, "/reverseSearch", WRITE_TO_DOC_LIST_KEY, - false, + writeToDocList, QUERY_MATCH_TYPE_KEY, "simple" }; QueryResponse response = query(params); System.out.println("Response = " + response); - validate(response, 0, List.of("1", "4")); - validate(response, 1, List.of("7")); - validate(response, 2, List.of("5")); + validate(response, 0, List.of("1", "4"), writeToDocList); + validate(response, 1, List.of("7"), writeToDocList); + validate(response, 2, List.of("5"), writeToDocList); assertEquals(0, ((SolrDocumentList) response.getResponse().get("response")).size()); } @@ -171,6 +173,7 @@ public void testDefaultParser() throws Exception { handle.put("responseHeader", SKIP); handle.put("response", SKIP); + final boolean writeToDocList = supportsWriteToDocList(); Object[] params = new Object[] { CommonParams.SORT, @@ -180,15 +183,15 @@ public void testDefaultParser() throws Exception { CommonParams.QT, "/reverseSearch", WRITE_TO_DOC_LIST_KEY, - supportsWriteToDocList(), + writeToDocList, QUERY_MATCH_TYPE_KEY, "simple" }; QueryResponse response = query(params); System.out.println("Response = " + response); - validate(response, 0, List.of("0")); - validate(response, 1, List.of("1")); + validate(response, 0, List.of("0"), writeToDocList); + validate(response, 1, List.of("1"), writeToDocList); } @Test @@ -209,6 +212,7 @@ public void testDisjunctionQuery() throws Exception { handle.put("responseHeader", SKIP); handle.put("response", SKIP); + final boolean writeToDocList = supportsWriteToDocList(); Object[] params = new Object[] { CommonParams.SORT, @@ -218,17 +222,17 @@ public void testDisjunctionQuery() throws Exception { CommonParams.QT, "/reverseSearch", WRITE_TO_DOC_LIST_KEY, - supportsWriteToDocList(), + writeToDocList, QUERY_MATCH_TYPE_KEY, "simple" }; QueryResponse response = query(params); System.out.println("Response = " + response); - if (supportsWriteToDocList()) { + if (writeToDocList) { assertEquals(3, ((SolrDocumentList) response.getResponse().get("response")).size()); } - validate(response, 0, List.of("0")); + validate(response, 0, List.of("0"), writeToDocList); } @Test @@ -243,6 +247,7 @@ public void testNoDanglingDecomposition() throws Exception { handle.put("responseHeader", SKIP); handle.put("response", SKIP); + final boolean writeToDocList = supportsWriteToDocList(); Object[] params = new Object[] { CommonParams.SORT, @@ -252,17 +257,17 @@ public void testNoDanglingDecomposition() throws Exception { CommonParams.QT, "/reverseSearch", WRITE_TO_DOC_LIST_KEY, - supportsWriteToDocList(), + writeToDocList, QUERY_MATCH_TYPE_KEY, "simple" }; QueryResponse response = query(params); System.out.println("Response = " + response); - if (supportsWriteToDocList()) { + if (writeToDocList) { assertEquals(1, ((SolrDocumentList) response.getResponse().get("response")).size()); } - validate(response, 0, List.of("0")); + validate(response, 0, List.of("0"), writeToDocList); index( id, @@ -272,10 +277,10 @@ public void testNoDanglingDecomposition() throws Exception { commit(); response = query(params); System.out.println("Response = " + response); - if (supportsWriteToDocList()) { + if (writeToDocList) { assertEquals(0, ((SolrDocumentList) response.getResponse().get("response")).size()); } - validate(response, 0, List.of()); + validate(response, 0, List.of(), writeToDocList); } @Test @@ -291,6 +296,7 @@ public void testNotQuery() throws Exception { handle.put("responseHeader", SKIP); handle.put("response", SKIP); + final boolean writeToDocList = supportsWriteToDocList(); Object[] params = new Object[] { CommonParams.SORT, @@ -300,14 +306,14 @@ public void testNotQuery() throws Exception { CommonParams.QT, "/reverseSearch", WRITE_TO_DOC_LIST_KEY, - supportsWriteToDocList(), + writeToDocList, QUERY_MATCH_TYPE_KEY, "simple" }; QueryResponse response = query(params); System.out.println("Response = " + response); - validate(response, 0, List.of("1")); + validate(response, 0, List.of("1"), writeToDocList); } @Test @@ -322,6 +328,7 @@ public void testWildCardQuery() throws Exception { handle.put("responseHeader", SKIP); handle.put("response", SKIP); + final boolean writeToDocList = supportsWriteToDocList(); Object[] params = new Object[] { CommonParams.SORT, @@ -331,18 +338,18 @@ public void testWildCardQuery() throws Exception { CommonParams.QT, "/reverseSearch", WRITE_TO_DOC_LIST_KEY, - supportsWriteToDocList(), + writeToDocList, QUERY_MATCH_TYPE_KEY, "simple" }; QueryResponse response = query(params); - if (supportsWriteToDocList()) { + if (writeToDocList) { assertEquals(3, ((SolrDocumentList) response.getResponse().get("response")).size()); } System.out.println("Response = " + response); - validate(response, 3, List.of("0", "1", "2")); - validate(response, 4, List.of("0", "1", "2")); + validate(response, 3, List.of("0", "1", "2"), writeToDocList); + validate(response, 4, List.of("0", "1", "2"), writeToDocList); } @Test @@ -355,6 +362,7 @@ public void testDefaultQueryMatchTypeIsNone() throws Exception { handle.put("responseHeader", SKIP); handle.put("response", SKIP); + final boolean writeToDocList = supportsWriteToDocList(); Object[] params = new Object[] { CommonParams.SORT, @@ -364,12 +372,12 @@ public void testDefaultQueryMatchTypeIsNone() throws Exception { CommonParams.QT, "/reverseSearch", WRITE_TO_DOC_LIST_KEY, - supportsWriteToDocList() + writeToDocList }; QueryResponse response = query(params); System.out.println("Response = " + response); - if (supportsWriteToDocList()) { + if (writeToDocList) { assertEquals(2, ((SolrDocumentList) response.getResponse().get("response")).size()); } assertNull(response.getResponse().get(MONITOR_OUTPUT_KEY)); @@ -404,6 +412,7 @@ public void testMultiDocHighlightMatchType() throws Exception { handle.put("responseHeader", SKIP); handle.put("response", SKIP); + final boolean writeToDocList = supportsWriteToDocList(); Object[] params = new Object[] { CommonParams.SORT, @@ -415,7 +424,7 @@ public void testMultiDocHighlightMatchType() throws Exception { QUERY_MATCH_TYPE_KEY, "highlights", WRITE_TO_DOC_LIST_KEY, - supportsWriteToDocList() + writeToDocList }; QueryResponse response = query(params); @@ -435,14 +444,14 @@ public void testMultiDocHighlightMatchType() throws Exception { new HighlightsMatch.Hit(1, 5, 1, 15), new HighlightsMatch.Hit(106, 38, 106, 43))); Map queryMatch4 = queryMatch("4", f1, List.of(new HighlightsMatch.Hit(0, 0, 0, 8)), f2, List.of()); - validate(response, 0, List.of(queryMatch0, queryMatch1, queryMatch4)); + validate(response, 0, List.of(queryMatch0, queryMatch1, queryMatch4), writeToDocList); queryMatch4 = queryMatch("4", f1, List.of(new HighlightsMatch.Hit(2, 7, 2, 15)), f2, List.of()); - validate(response, 1, List.of(queryMatch4)); + validate(response, 1, List.of(queryMatch4), writeToDocList); var queries = monitorQueries(response, 0); assertEquals(3, queries.size()); queries = monitorQueries(response, 1); assertEquals(1, queries.size()); - if (supportsWriteToDocList()) { + if (writeToDocList) { assertEquals(3, ((SolrDocumentList) response.getResponse().get("response")).size()); } } @@ -465,6 +474,7 @@ public void testHighlightMatchType() throws Exception { handle.put("responseHeader", SKIP); handle.put("response", SKIP); + final boolean writeToDocList = supportsWriteToDocList(); Object[] params = new Object[] { CommonParams.SORT, @@ -476,7 +486,7 @@ public void testHighlightMatchType() throws Exception { QUERY_MATCH_TYPE_KEY, "highlights", WRITE_TO_DOC_LIST_KEY, - supportsWriteToDocList() + writeToDocList }; QueryResponse response = query(params); @@ -494,10 +504,10 @@ public void testHighlightMatchType() throws Exception { f2, List.of( new HighlightsMatch.Hit(1, 5, 1, 15), new HighlightsMatch.Hit(106, 38, 106, 43))); - validate(response, 0, List.of(queryMatch0, queryMatch1)); + validate(response, 0, List.of(queryMatch0, queryMatch1), writeToDocList); var queries = monitorQueries(response, 0); assertEquals(2, queries.size()); - if (supportsWriteToDocList()) { + if (writeToDocList) { // The disjuncts come in as separate matches // TODO is this the most desirable behavior? assertEquals(4, ((SolrDocumentList) response.getResponse().get("response")).size()); @@ -516,6 +526,7 @@ public void testDeleteByQueryId() throws Exception { handle.put("responseHeader", SKIP); handle.put("response", SKIP); + final boolean writeToDocList = supportsWriteToDocList(); Object[] params = new Object[] { CommonParams.SORT, @@ -525,16 +536,16 @@ public void testDeleteByQueryId() throws Exception { CommonParams.QT, "/reverseSearch", WRITE_TO_DOC_LIST_KEY, - supportsWriteToDocList(), + writeToDocList, QUERY_MATCH_TYPE_KEY, "simple" }; QueryResponse response = query(params); - if (supportsWriteToDocList()) { + if (writeToDocList) { assertEquals(1, ((SolrDocumentList) response.getResponse().get("response")).size()); } - validate(response, 0, List.of("0")); + validate(response, 0, List.of("0"), writeToDocList); del(MonitorFields.QUERY_ID + ":0"); commit(); @@ -576,15 +587,35 @@ static List map(List hits) { return outHits; } - void validate(QueryResponse response, int doc, Object expectedValue) { + void validate(QueryResponse response, int doc, Object expectedValue, boolean writeToDocList) { var monitorQueries = monitorQueries(response, doc); assertEquals(expectedValue, monitorQueries); + if (writeToDocList) { + validateDocList(response, doc, expectedValue); + } } - void validate(QueryResponse response, int doc, int query, Object expectedValue) { + void validate( + QueryResponse response, int doc, int query, Object expectedValue, boolean writeToDocList) { var monitorQueries = monitorQueries(response, doc); assertTrue(monitorQueries.size() > query); assertEquals(expectedValue, monitorQueries.get(query)); + if (writeToDocList) { + validateDocList(response, doc, expectedValue); + } + } + + void validateDocList(QueryResponse response, int doc, 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; + if (expectedValues.size() == 1 && actualValues.size() <= 2) { + assertEquals( + expectedValues.get(0), + actualValues.get(actualValues.size() - 1 - doc).getFieldValue(MonitorFields.QUERY_ID)); + } + } } List monitorQueries(QueryResponse response, int doc) { diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java index c0fc490caab5..89b484fbdfe6 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java @@ -73,7 +73,7 @@ public void manySegmentsQuery() throws Exception { }; QueryResponse response = query(params); - validate(response, 0, 0, "0"); + validate(response, 0, 0, "0", false); assertEquals(count, ((Map) response.getResponse().get("monitor")).get("queriesRun")); assertEquals( count, @@ -98,7 +98,7 @@ public void manySegmentsQuery() throws Exception { commit(); response = query(params); - validate(response, 0, 0, "0"); + validate(response, 0, 0, "0", false); assertEquals(count / 2, ((Map) response.getResponse().get("monitor")).get("queriesRun")); assertEquals( count / 2, @@ -138,7 +138,7 @@ public void multiPassPresearcherTest() throws Exception { QueryResponse response = query(params); assertEquals(1, ((Map) response.getResponse().get("monitor")).get("queriesRun")); - validate(response, 0, 0, "3"); + validate(response, 0, 0, "3", false); } @Override From d359f80a1b23a90b40d3a095a287e68eb07a1cc7 Mon Sep 17 00:00:00 2001 From: Christine Poerschke Date: Mon, 17 Jun 2024 16:52:39 +0100 Subject: [PATCH 41/85] defer parallel matching from initial integration --- .../search/ParallelSolrMatcherSink.java | 95 ----------- .../search/ReverseSearchComponent.java | 22 +-- .../solr/monitor/search/SolrMatcherSink.java | 2 - .../search/SolrMatcherSinkFactory.java | 12 -- .../monitor/search/SyncSolrMatcherSink.java | 5 - .../solr/collection1/solrconfig-parallel.xml | 144 ----------------- .../monitor/ParallelMonitorSolrQueryTest.java | 148 ------------------ 7 files changed, 1 insertion(+), 427 deletions(-) delete mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java delete mode 100644 solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml delete mode 100644 solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java deleted file mode 100644 index dee972ebf50a..000000000000 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ParallelSolrMatcherSink.java +++ /dev/null @@ -1,95 +0,0 @@ -/* - * - * * 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.monitor.search; - -import java.io.IOException; -import java.util.ArrayList; -import java.util.List; -import java.util.Map; -import java.util.concurrent.CompletionService; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.ExecutorCompletionService; -import java.util.concurrent.ExecutorService; -import java.util.function.Consumer; -import java.util.function.Function; -import org.apache.lucene.monitor.CandidateMatcher; -import org.apache.lucene.monitor.MatchesAggregator; -import org.apache.lucene.monitor.MultiMatchingQueries; -import org.apache.lucene.monitor.QueryMatch; -import org.apache.lucene.search.IndexSearcher; -import org.apache.lucene.search.Query; - -class ParallelSolrMatcherSink implements SolrMatcherSink { - - private final CompletionService> completionService; - private final Function> matcherFactory; - private final IndexSearcher docBatchSearcher; - private final Consumer> queriesConsumer; - private int tasksLeft; - - public ParallelSolrMatcherSink( - ExecutorService executor, - Function> matcherFactory, - IndexSearcher docBatchSearcher, - Consumer> queriesConsumer) { - this.completionService = new ExecutorCompletionService<>(executor); - this.matcherFactory = matcherFactory; - this.docBatchSearcher = docBatchSearcher; - this.queriesConsumer = queriesConsumer; - } - - @Override - public boolean matchQuery(String queryId, Query matchQuery, Map metadata) { - completionService.submit( - () -> { - var matcher = matcherFactory.apply(docBatchSearcher); - matcher.matchQuery(queryId, matchQuery, metadata); - return matcher; - }); - tasksLeft++; - return false; - } - - @Override - public void complete() throws IOException { - List> matchingQueries = new ArrayList<>(); - int queryCount = tasksLeft; - while (tasksLeft-- > 0) { - try { - matchingQueries.add(completionService.take().get()); - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - throw new IOException(e); - } catch (ExecutionException e) { - throw new IllegalStateException( - CandidateMatcher.class.getSimpleName() + " should never throw an exception", e); - } - } - var resolvingMatcher = matcherFactory.apply(docBatchSearcher); - var aggregateMatches = - MatchesAggregator.aggregate(matchingQueries, resolvingMatcher, queryCount); - queriesConsumer.accept(aggregateMatches); - } - - @Override - public boolean isParallel() { - return true; - } -} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 9d9653502453..25e9055c07c4 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -77,8 +77,7 @@ public class ReverseSearchComponent extends QueryComponent implements SolrCoreAw private QueryDecomposer queryDecomposer; private Presearcher presearcher; - private SolrMatcherSinkFactory solrMatcherSinkFactory = new SolrMatcherSinkFactory(); - private ExecutorService executor; + final private SolrMatcherSinkFactory solrMatcherSinkFactory = new SolrMatcherSinkFactory(); private PresearcherFactory.PresearcherParameters presearcherParameters; @Override @@ -88,13 +87,6 @@ public void init(NamedList args) { if (solrMonitorCacheName != null) { this.solrMonitorCacheName = (String) solrMonitorCacheName; } - Object threadCount = args.remove(MATCHER_THREAD_COUNT_KEY); - if (threadCount instanceof Integer) { - executor = - ExecutorUtil.newMDCAwareFixedThreadPool( - (Integer) threadCount, new NamedThreadFactory("monitor-matcher")); - solrMatcherSinkFactory = new SolrMatcherSinkFactory(executor); - } presearcherParameters = new PresearcherFactory.PresearcherParameters(); SolrPluginUtils.invokeSetters(presearcherParameters, args); } @@ -107,11 +99,6 @@ public void prepare(ResponseBuilder rb) { var matchType = QueryMatchType.fromString(req.getParams().get(QUERY_MATCH_TYPE_KEY)); Map monitorResult = new HashMap<>(); var matcherSink = solrMatcherSinkFactory.build(matchType, documentBatch, monitorResult); - if (matcherSink.isParallel() && writeToDocList) { - throw new SolrException( - ErrorCode.BAD_REQUEST, - "writeToDocList is not supported for parallel matcher. Consider adding more shards/cores instead of parallel matcher."); - } Query preFilterQuery = presearcher.buildQuery(documentBatch.get(), getTermAcceptor(rb.req)); List mutableFilters = Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); @@ -181,13 +168,6 @@ public String getDescription() { @Override public void inform(SolrCore core) { - core.addCloseHook( - new CloseHook() { - @Override - public void preClose(SolrCore core) { - ExecutorUtil.shutdownAndAwaitTermination(executor); - } - }); queryDecomposer = new QueryDecomposer(); presearcher = PresearcherFactory.build(core.getResourceLoader(), presearcherParameters); var schema = core.getLatestSchema(); diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java index 2e23a4795282..4a0d7317f68c 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java @@ -29,6 +29,4 @@ boolean matchQuery(String queryId, Query matchQuery, Map metadat throws IOException; void complete() throws IOException; - - boolean isParallel(); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java index af6a28bfdc42..2dd24427a321 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java @@ -32,14 +32,7 @@ class SolrMatcherSinkFactory { - private final ExecutorService executorService; - SolrMatcherSinkFactory() { - this(null); - } - - SolrMatcherSinkFactory(ExecutorService executorService) { - this.executorService = executorService; } SolrMatcherSink build( @@ -73,11 +66,6 @@ private SolrMatcherSink build( Function> matcherFactory, Consumer> encoder) { var docBatchSearcher = new IndexSearcher(documentBatch.get()); - if (executorService == null) { return new SyncSolrMatcherSink<>(matcherFactory, docBatchSearcher, encoder); - } else { - return new ParallelSolrMatcherSink<>( - executorService, matcherFactory, docBatchSearcher, encoder); - } } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java index 835990990afe..238cd12fe0f9 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java @@ -71,9 +71,4 @@ public void complete() { queriesConsumer.accept( MatchesAggregator.aggregate(matchers, matcherFactory.apply(docBatchSearcher), queryCount)); } - - @Override - public boolean isParallel() { - return false; - } } diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml deleted file mode 100644 index 4cac6076c13b..000000000000 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-parallel.xml +++ /dev/null @@ -1,144 +0,0 @@ - - - - - ${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 - 16 - MultipassTermFilteredPresearcher - true - 4 - - - - - - - - - - - text/plain; charset=UTF-8 - - - diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java deleted file mode 100644 index c0fc490caab5..000000000000 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java +++ /dev/null @@ -1,148 +0,0 @@ -/* - * - * * 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.monitor; - -import static org.apache.solr.monitor.MonitorConstants.QUERY_MATCH_TYPE_KEY; - -import java.util.List; -import java.util.Map; -import java.util.stream.IntStream; -import org.apache.lucene.monitor.MonitorFields; -import org.apache.solr.client.solrj.response.QueryResponse; -import org.apache.solr.common.params.CommonParams; -import org.junit.BeforeClass; -import org.junit.Test; - -public class ParallelMonitorSolrQueryTest extends MonitorSolrQueryTest { - - @BeforeClass - public static void beforeSuperClass() { - configString = "solrconfig-parallel.xml"; - schemaString = "schema-aliasing.xml"; - } - - @Test - @SuppressWarnings("rawtypes") - public void manySegmentsQuery() throws Exception { - int count = 10_000; - IntStream.range(0, count) - .forEach( - i -> { - try { - index( - id, - Integer.toString(i), - MonitorFields.MONITOR_QUERY, - "content_s:\"elevator stairs\""); - } catch (Exception e) { - throw new IllegalStateException(e); - } - }); - commit(); - handle.clear(); - handle.put("responseHeader", SKIP); - handle.put("response", SKIP); - - Object[] params = - new Object[] { - CommonParams.SORT, - id + " desc", - CommonParams.JSON, - read("/monitor/multi-doc-batch.json"), - CommonParams.QT, - "/reverseSearch", - QUERY_MATCH_TYPE_KEY, - "simple" - }; - - QueryResponse response = query(params); - validate(response, 0, 0, "0"); - assertEquals(count, ((Map) response.getResponse().get("monitor")).get("queriesRun")); - assertEquals( - count, - ((List) - ((Map) - ((Map) - ((Map) response.getResponse().get("monitor")) - .get("monitorDocuments")) - .get(0)) - .get("queries")) - .size()); - - IntStream.range(count / 2, count) - .forEach( - i -> { - try { - index(id, Integer.toString(i), MonitorFields.MONITOR_QUERY, "content_s:\"x y\""); - } catch (Exception e) { - throw new IllegalStateException(e); - } - }); - commit(); - - response = query(params); - validate(response, 0, 0, "0"); - assertEquals(count / 2, ((Map) response.getResponse().get("monitor")).get("queriesRun")); - assertEquals( - count / 2, - ((List) - ((Map) - ((Map) - ((Map) response.getResponse().get("monitor")) - .get("monitorDocuments")) - .get(0)) - .get("queries")) - .size()); - } - - @Test - @SuppressWarnings("unchecked") - public void multiPassPresearcherTest() throws Exception { - index(id, "0", MonitorFields.MONITOR_QUERY, "content0_s:\"elevator stairs and escalator\""); - index(id, "1", MonitorFields.MONITOR_QUERY, "content0_s:\"elevator test\""); - index(id, "2", MonitorFields.MONITOR_QUERY, "content0_s:\"stairs test\""); - index(id, "3", MonitorFields.MONITOR_QUERY, "content0_s:\"elevator stairs\""); - commit(); - handle.clear(); - handle.put("responseHeader", SKIP); - handle.put("response", SKIP); - - Object[] params = - new Object[] { - CommonParams.SORT, - id + " desc", - CommonParams.JSON, - read("/monitor/single-doc-batch.json"), - CommonParams.QT, - "/reverseSearch", - QUERY_MATCH_TYPE_KEY, - "simple" - }; - - QueryResponse response = query(params); - assertEquals(1, ((Map) response.getResponse().get("monitor")).get("queriesRun")); - validate(response, 0, 0, "3"); - } - - @Override - protected boolean supportsWriteToDocList() { - return false; - } -} From 4af2c57caaba88a6f0d7f06eedd0a2029a3499f7 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 21 Jun 2024 21:01:58 -0400 Subject: [PATCH 42/85] move manySegments and multiPass to SingleCoreMonitorSolrTest --- ...ributed.xml => solrconfig-single-core.xml} | 0 .../monitor/ParallelMonitorSolrQueryTest.java | 112 ----------------- ...st.java => SingleCoreMonitorSolrTest.java} | 114 +++++++++++++++++- 3 files changed, 108 insertions(+), 118 deletions(-) rename solr/modules/monitor/src/test-files/solr/collection1/{solrconfig-not-distributed.xml => solrconfig-single-core.xml} (100%) rename solr/modules/monitor/src/test/org/apache/solr/monitor/{NonDistributedMonitorTest.java => SingleCoreMonitorSolrTest.java} (53%) diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-not-distributed.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-single-core.xml similarity index 100% rename from solr/modules/monitor/src/test-files/solr/collection1/solrconfig-not-distributed.xml rename to solr/modules/monitor/src/test-files/solr/collection1/solrconfig-single-core.xml diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java index c0fc490caab5..0c27f5ad366e 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java @@ -19,16 +19,7 @@ package org.apache.solr.monitor; -import static org.apache.solr.monitor.MonitorConstants.QUERY_MATCH_TYPE_KEY; - -import java.util.List; -import java.util.Map; -import java.util.stream.IntStream; -import org.apache.lucene.monitor.MonitorFields; -import org.apache.solr.client.solrj.response.QueryResponse; -import org.apache.solr.common.params.CommonParams; import org.junit.BeforeClass; -import org.junit.Test; public class ParallelMonitorSolrQueryTest extends MonitorSolrQueryTest { @@ -38,109 +29,6 @@ public static void beforeSuperClass() { schemaString = "schema-aliasing.xml"; } - @Test - @SuppressWarnings("rawtypes") - public void manySegmentsQuery() throws Exception { - int count = 10_000; - IntStream.range(0, count) - .forEach( - i -> { - try { - index( - id, - Integer.toString(i), - MonitorFields.MONITOR_QUERY, - "content_s:\"elevator stairs\""); - } catch (Exception e) { - throw new IllegalStateException(e); - } - }); - commit(); - handle.clear(); - handle.put("responseHeader", SKIP); - handle.put("response", SKIP); - - Object[] params = - new Object[] { - CommonParams.SORT, - id + " desc", - CommonParams.JSON, - read("/monitor/multi-doc-batch.json"), - CommonParams.QT, - "/reverseSearch", - QUERY_MATCH_TYPE_KEY, - "simple" - }; - - QueryResponse response = query(params); - validate(response, 0, 0, "0"); - assertEquals(count, ((Map) response.getResponse().get("monitor")).get("queriesRun")); - assertEquals( - count, - ((List) - ((Map) - ((Map) - ((Map) response.getResponse().get("monitor")) - .get("monitorDocuments")) - .get(0)) - .get("queries")) - .size()); - - IntStream.range(count / 2, count) - .forEach( - i -> { - try { - index(id, Integer.toString(i), MonitorFields.MONITOR_QUERY, "content_s:\"x y\""); - } catch (Exception e) { - throw new IllegalStateException(e); - } - }); - commit(); - - response = query(params); - validate(response, 0, 0, "0"); - assertEquals(count / 2, ((Map) response.getResponse().get("monitor")).get("queriesRun")); - assertEquals( - count / 2, - ((List) - ((Map) - ((Map) - ((Map) response.getResponse().get("monitor")) - .get("monitorDocuments")) - .get(0)) - .get("queries")) - .size()); - } - - @Test - @SuppressWarnings("unchecked") - public void multiPassPresearcherTest() throws Exception { - index(id, "0", MonitorFields.MONITOR_QUERY, "content0_s:\"elevator stairs and escalator\""); - index(id, "1", MonitorFields.MONITOR_QUERY, "content0_s:\"elevator test\""); - index(id, "2", MonitorFields.MONITOR_QUERY, "content0_s:\"stairs test\""); - index(id, "3", MonitorFields.MONITOR_QUERY, "content0_s:\"elevator stairs\""); - commit(); - handle.clear(); - handle.put("responseHeader", SKIP); - handle.put("response", SKIP); - - Object[] params = - new Object[] { - CommonParams.SORT, - id + " desc", - CommonParams.JSON, - read("/monitor/single-doc-batch.json"), - CommonParams.QT, - "/reverseSearch", - QUERY_MATCH_TYPE_KEY, - "simple" - }; - - QueryResponse response = query(params); - assertEquals(1, ((Map) response.getResponse().get("monitor")).get("queriesRun")); - validate(response, 0, 0, "3"); - } - @Override protected boolean supportsWriteToDocList() { return false; diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/NonDistributedMonitorTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java similarity index 53% rename from solr/modules/monitor/src/test/org/apache/solr/monitor/NonDistributedMonitorTest.java rename to solr/modules/monitor/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java index e43411fd7522..1557e2244445 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/NonDistributedMonitorTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java @@ -27,6 +27,7 @@ import java.nio.file.Files; import java.nio.file.Path; import java.util.Locale; +import java.util.stream.IntStream; import org.apache.lucene.monitor.MonitorFields; import org.apache.solr.SolrTestCaseJ4; import org.apache.solr.common.SolrException; @@ -35,11 +36,13 @@ import org.junit.BeforeClass; import org.junit.Test; -public class NonDistributedMonitorTest extends SolrTestCaseJ4 { +public class SingleCoreMonitorSolrTest extends SolrTestCaseJ4 { + + private final String monitorChain = "monitor"; @BeforeClass public static void beforeTests() throws Exception { - initCore("solrconfig-not-distributed.xml", "schema-aliasing.xml"); + initCore("solrconfig-single-core.xml", "schema-aliasing.xml"); } @Override @@ -55,7 +58,6 @@ public void coexistWithRegularDocumentsTest() throws Exception { String regularChain = "regular-ole-document"; addDoc(adoc("id", "0", "content_s", "some unremarkable content"), regularChain); addDoc(commit(), regularChain); - String monitorChain = "monitor"; addDoc(adoc("id", "1", MonitorFields.MONITOR_QUERY, "content_s:test"), monitorChain); addDoc(commit(), monitorChain); URL url = getClass().getResource("/monitor/multi-doc-batch.json"); @@ -80,7 +82,6 @@ public void coexistWithRegularDocumentsTest() throws Exception { @Test public void queryStringIdTest() throws Exception { - String monitorChain = "monitor"; addDoc(adoc("id", "1", MonitorFields.MONITOR_QUERY, "id:4"), monitorChain); addDoc(adoc("id", "2", MonitorFields.MONITOR_QUERY, "id:4"), monitorChain); addDoc(commit(), monitorChain); @@ -106,7 +107,6 @@ public void queryStringIdTest() throws Exception { @Test public void missingQueryFieldTest() { - String monitorChain = "monitor"; 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); @@ -118,7 +118,6 @@ public void missingQueryFieldTest() { @Test public void unsupportedFieldTest() { - String monitorChain = "monitor"; String unsupportedField1 = "unsupported2_s"; String unsupportedField2 = "unsupported2_s"; var ex = @@ -143,4 +142,107 @@ public void unsupportedFieldTest() { 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/single-doc-batch.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", + QUERY_MATCH_TYPE_KEY, + "simple" + }; + + assertQ( + req(params), + "/response/lst[@name=\"monitor\"]/int[@name=\"queriesRun\"]/text()='1'", + "/response/lst[@name=\"monitor\"]/lst[@name=\"monitorDocuments\"]/lst[@name=\"0\"]/int[@name=\"monitorDocument\"]/text()='0'", + "/response/lst[@name=\"monitor\"]/lst[@name=\"monitorDocuments\"]/lst[@name=\"0\"]/arr[@name=\"queries\"]/str/text()='3'"); + } + + @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-doc-batch.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", + QUERY_MATCH_TYPE_KEY, + "simple" + }; + + assertQ( + req(params), + "/response/lst[@name=\"monitor\"]/int[@name=\"queriesRun\"]/text()='" + count + "'", + "/response/lst[@name=\"monitor\"]/lst[@name=\"monitorDocuments\"]/lst[@name=\"0\"]/int[@name=\"monitorDocument\"]/text()='0'", + "/response/lst[@name=\"monitor\"]/lst[@name=\"monitorDocuments\"]/lst[@name=\"0\"]/arr[@name=\"queries\"]/str/text()='0'", + "count(/response/lst[@name=\"monitor\"]/lst[@name=\"monitorDocuments\"]/lst[@name=\"0\"]/arr[@name=\"queries\"]/str)=" + + 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), + "/response/lst[@name=\"monitor\"]/int[@name=\"queriesRun\"]/text()='" + (count / 2) + "'", + "/response/lst[@name=\"monitor\"]/lst[@name=\"monitorDocuments\"]/lst[@name=\"0\"]/int[@name=\"monitorDocument\"]/text()='0'", + "/response/lst[@name=\"monitor\"]/lst[@name=\"monitorDocuments\"]/lst[@name=\"0\"]/arr[@name=\"queries\"]/str/text()='0'", + "count(/response/lst[@name=\"monitor\"]/lst[@name=\"monitorDocuments\"]/lst[@name=\"0\"]/arr[@name=\"queries\"]/str)=" + + (count / 2)); + } } From 7feb4156f3a707ec07ce7c9c512c81e8d1408093 Mon Sep 17 00:00:00 2001 From: Christine Poerschke Date: Mon, 24 Jun 2024 14:20:04 +0100 Subject: [PATCH 43/85] restore ParallelMonitorSolrQueryTest.java --- .../monitor/ParallelMonitorSolrQueryTest.java | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.java new file mode 100644 index 000000000000..0c27f5ad366e --- /dev/null +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/ParallelMonitorSolrQueryTest.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.monitor; + +import org.junit.BeforeClass; + +public class ParallelMonitorSolrQueryTest extends MonitorSolrQueryTest { + + @BeforeClass + public static void beforeSuperClass() { + configString = "solrconfig-parallel.xml"; + schemaString = "schema-aliasing.xml"; + } + + @Override + protected boolean supportsWriteToDocList() { + return false; + } +} From e33e8aee95c7042a20555c4c33e512465c21487c Mon Sep 17 00:00:00 2001 From: Christine Poerschke Date: Mon, 24 Jun 2024 17:30:19 +0100 Subject: [PATCH 44/85] ./gradlew tidy --- .../apache/solr/monitor/search/ReverseSearchComponent.java | 7 +------ .../apache/solr/monitor/search/SolrMatcherSinkFactory.java | 6 ++---- 2 files changed, 3 insertions(+), 10 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 25e9055c07c4..962aaa9fc814 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -33,7 +33,6 @@ import java.util.List; import java.util.Map; import java.util.Optional; -import java.util.concurrent.ExecutorService; import java.util.function.BiPredicate; import java.util.stream.Collectors; import org.apache.lucene.document.Document; @@ -45,12 +44,8 @@ import org.apache.lucene.search.MatchAllDocsQuery; import org.apache.lucene.search.Query; import org.apache.lucene.util.BytesRef; -import org.apache.lucene.util.NamedThreadFactory; import org.apache.solr.common.SolrException; -import org.apache.solr.common.SolrException.ErrorCode; -import org.apache.solr.common.util.ExecutorUtil; import org.apache.solr.common.util.NamedList; -import org.apache.solr.core.CloseHook; import org.apache.solr.core.SolrCore; import org.apache.solr.handler.component.QueryComponent; import org.apache.solr.handler.component.ResponseBuilder; @@ -77,7 +72,7 @@ public class ReverseSearchComponent extends QueryComponent implements SolrCoreAw private QueryDecomposer queryDecomposer; private Presearcher presearcher; - final private SolrMatcherSinkFactory solrMatcherSinkFactory = new SolrMatcherSinkFactory(); + private final SolrMatcherSinkFactory solrMatcherSinkFactory = new SolrMatcherSinkFactory(); private PresearcherFactory.PresearcherParameters presearcherParameters; @Override diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java index 2dd24427a321..e16ce2c481c5 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java @@ -20,7 +20,6 @@ package org.apache.solr.monitor.search; import java.util.Map; -import java.util.concurrent.ExecutorService; import java.util.function.Consumer; import java.util.function.Function; import org.apache.lucene.monitor.CandidateMatcher; @@ -32,8 +31,7 @@ class SolrMatcherSinkFactory { - SolrMatcherSinkFactory() { - } + SolrMatcherSinkFactory() {} SolrMatcherSink build( QueryMatchType matchType, @@ -66,6 +64,6 @@ private SolrMatcherSink build( Function> matcherFactory, Consumer> encoder) { var docBatchSearcher = new IndexSearcher(documentBatch.get()); - return new SyncSolrMatcherSink<>(matcherFactory, docBatchSearcher, encoder); + return new SyncSolrMatcherSink<>(matcherFactory, docBatchSearcher, encoder); } } From 05438f4cc5993e7d1ae695b073fd7484b80b39ab Mon Sep 17 00:00:00 2001 From: Christine Poerschke Date: Mon, 24 Jun 2024 18:14:17 +0100 Subject: [PATCH 45/85] defer monitorMatchType support (always use simple matching) --- .../apache/solr/monitor/MonitorConstants.java | 2 - .../search/QueryMatchResponseCodec.java | 89 +------ .../solr/monitor/search/QueryMatchType.java | 45 ---- .../search/ReverseSearchComponent.java | 19 +- .../search/SolrMatcherSinkFactory.java | 26 +- .../search/SolrMonitorQueryCollector.java | 17 +- .../solr/monitor/MonitorSolrQueryTest.java | 236 +----------------- .../monitor/SingleCoreMonitorSolrTest.java | 23 +- 8 files changed, 34 insertions(+), 423 deletions(-) delete mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchType.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java index be775c2f2963..756097fc663e 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java @@ -27,8 +27,6 @@ private MonitorConstants() {} public static final String MONITOR_DOCUMENT_KEY = "monitorDocument"; public static final String MONITOR_QUERIES_KEY = "queries"; public static final String MONITOR_QUERIES_RUN = "queriesRun"; - public static final String QUERY_MATCH_TYPE_KEY = "monitorMatchType"; public static final String MONITOR_OUTPUT_KEY = "monitor"; public static final String WRITE_TO_DOC_LIST_KEY = "writeToDocList"; - public static final String HITS_KEY = "hits"; } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchResponseCodec.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchResponseCodec.java index 2db12be8f4f5..3d169fbd24e3 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchResponseCodec.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchResponseCodec.java @@ -35,20 +35,16 @@ import java.util.stream.Collectors; import java.util.stream.IntStream; import java.util.stream.Stream; -import org.apache.lucene.monitor.HighlightsMatch; -import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.monitor.MultiMatchingQueries; import org.apache.lucene.monitor.QueryMatch; import org.apache.lucene.util.BytesRef; import org.apache.solr.common.SolrException; import org.apache.solr.common.util.NamedList; -import org.apache.solr.monitor.MonitorConstants; @SuppressWarnings("unchecked") class QueryMatchResponseCodec { - static Map mergeResponses( - List> responses, QueryMatchType type) { + static Map mergeResponses(List> responses) { Map> wrappedMerged = new HashMap<>(); int queriesRun = 0; for (var response : responses) { @@ -58,7 +54,7 @@ static Map mergeResponses( SolrException.ErrorCode.BAD_REQUEST, MONITOR_OUTPUT_KEY + " must be a map"); } Map singleMonitorOutput = (Map) smq; - decodeToWrappers(singleMonitorOutput, wrappedMerged, type); + decodeToWrappers(singleMonitorOutput, wrappedMerged); var delta = singleMonitorOutput.get(MONITOR_QUERIES_RUN); if (!(delta instanceof Integer)) { throw new SolrException( @@ -83,7 +79,7 @@ static Map mergeResponses( } private static void decodeToWrappers( - Object object, Map> output, QueryMatchType type) { + Object object, Map> output) { if (!(object instanceof Map)) { throw new IllegalArgumentException("input object should be a map"); } @@ -109,15 +105,9 @@ private static void decodeToWrappers( int doc = (Integer) docRaw; List wrappers = output.computeIfAbsent(doc, i -> new ArrayList<>()); List serializableFormMQs = (List) monitorQueriesRaw; - if (type == QueryMatchType.SIMPLE) { - serializableFormMQs.forEach( - serializableForm -> - wrappers.add(SimpleQueryMatchWrapper.fromSerializableForm(serializableForm))); - } else if (type == QueryMatchType.HIGHLIGHTS) { - serializableFormMQs.forEach( - serializableForm -> - wrappers.add(HighlightedQueryMatchWrapper.fromSerializableForm(serializableForm))); - } + serializableFormMQs.forEach( + serializableForm -> + wrappers.add(SimpleQueryMatchWrapper.fromSerializableForm(serializableForm))); } } @@ -129,14 +119,6 @@ static void simpleEncode( matchingQueries, output, docBatchSize, SimpleQueryMatchWrapper::fromQueryMatch); } - static void highlightEncode( - MultiMatchingQueries matchingQueries, - Map output, - int docBatchSize) { - encodeMultiMatchingQuery( - matchingQueries, output, docBatchSize, HighlightedQueryMatchWrapper::new); - } - private static void encodeMultiMatchingQuery( MultiMatchingQueries matchingQueries, Map output, @@ -217,63 +199,4 @@ public BytesRef queryId() { return queryId; } } - - private static class HighlightedQueryMatchWrapper implements QueryMatchWrapper { - - private final BytesRef queryId; - private final Map hits; - - private HighlightedQueryMatchWrapper(HighlightsMatch highlightsMatch) { - this( - new BytesRef(highlightsMatch.getQueryId()), - highlightsMatch.getHits().entrySet().stream() - .collect( - Collectors.toMap( - Map.Entry::getKey, - entry -> - entry.getValue().stream() - .map(HighlightedQueryMatchWrapper::hitMap) - .collect(Collectors.toList())))); - } - - private static Map hitMap(HighlightsMatch.Hit hit) { - Map map = new LinkedHashMap<>(); - map.put("startPosition", hit.startPosition); - map.put("endPosition", hit.endPosition); - map.put("startOffset", hit.startOffset); - map.put("endOffset", hit.endOffset); - return map; - } - - private HighlightedQueryMatchWrapper(BytesRef queryId, Map hits) { - this.hits = hits; - this.queryId = queryId; - } - - @Override - public Object toSerializableForm() { - Map map = new LinkedHashMap<>(); - map.put(MonitorFields.QUERY_ID, queryId.utf8ToString()); - map.put(MonitorConstants.HITS_KEY, hits); - return map; - } - - private static HighlightedQueryMatchWrapper fromSerializableForm(Object serializableForm) { - if (!(serializableForm instanceof Map)) { - decodingError(serializableForm, HighlightedQueryMatchWrapper.class); - } - Object queryId = ((Map) serializableForm).get(MonitorFields.QUERY_ID); - Object hits = ((Map) serializableForm).get(MonitorConstants.HITS_KEY); - if (!(queryId instanceof String) || !(hits instanceof Map)) { - decodingError(serializableForm, HighlightedQueryMatchWrapper.class); - } - return new HighlightedQueryMatchWrapper( - new BytesRef((String) queryId), (Map) hits); - } - - @Override - public BytesRef queryId() { - return queryId; - } - } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchType.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchType.java deleted file mode 100644 index b4d8f6ac35c3..000000000000 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchType.java +++ /dev/null @@ -1,45 +0,0 @@ -/* - * - * * 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.monitor.search; - -public enum QueryMatchType { - SIMPLE, - HIGHLIGHTS, - NONE; - - public final boolean needsScores; - - QueryMatchType() { - this(false); - } - - QueryMatchType(boolean needsScores) { - this.needsScores = needsScores; - } - - static QueryMatchType fromString(String matchType) { - if (SIMPLE.name().equalsIgnoreCase(matchType)) { - return SIMPLE; - } else if (HIGHLIGHTS.name().equalsIgnoreCase(matchType)) { - return HIGHLIGHTS; - } - return NONE; - } -} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 962aaa9fc814..22106a48597c 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -21,10 +21,8 @@ import static org.apache.solr.monitor.MonitorConstants.MONITOR_DOCUMENTS_KEY; import static org.apache.solr.monitor.MonitorConstants.MONITOR_OUTPUT_KEY; -import static org.apache.solr.monitor.MonitorConstants.QUERY_MATCH_TYPE_KEY; import static org.apache.solr.monitor.MonitorConstants.WRITE_TO_DOC_LIST_KEY; import static org.apache.solr.monitor.search.PresearcherFactory.DEFAULT_ALIAS_PREFIX; -import static org.apache.solr.monitor.search.QueryMatchResponseCodec.mergeResponses; import java.util.ArrayList; import java.util.Arrays; @@ -91,9 +89,8 @@ public void prepare(ResponseBuilder rb) { var req = rb.req; var documentBatch = documentBatch(req); boolean writeToDocList = req.getParams().getBool(WRITE_TO_DOC_LIST_KEY, false); - var matchType = QueryMatchType.fromString(req.getParams().get(QUERY_MATCH_TYPE_KEY)); Map monitorResult = new HashMap<>(); - var matcherSink = solrMatcherSinkFactory.build(matchType, documentBatch, monitorResult); + var matcherSink = solrMatcherSinkFactory.build(documentBatch, monitorResult); Query preFilterQuery = presearcher.buildQuery(documentBatch.get(), getTermAcceptor(rb.req)); List mutableFilters = Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); @@ -106,12 +103,9 @@ public void prepare(ResponseBuilder rb) { mutableFilters.add( new MonitorPostFilter( new SolrMonitorQueryCollector.CollectorContext( - solrMonitorCache, queryDecoder, matcherSink, writeToDocList, matchType))); + solrMonitorCache, queryDecoder, matcherSink, writeToDocList))); rb.setFilters(mutableFilters); - rb.rsp.add(QUERY_MATCH_TYPE_KEY, matchType.name()); - if (matchType != QueryMatchType.NONE) { - rb.rsp.add(MONITOR_OUTPUT_KEY, monitorResult); - } + rb.rsp.add(MONITOR_OUTPUT_KEY, monitorResult); } @SuppressWarnings({"unchecked"}) @@ -149,11 +143,8 @@ public void handleResponses(ResponseBuilder rb, ShardRequest sreq) { .map(shardResponse -> shardResponse.getSolrResponse().getResponse()) .collect(Collectors.toList()); rb.rsp.getValues().removeAll(MONITOR_OUTPUT_KEY); - var matchType = QueryMatchType.fromString(rb.req.getParams().get(QUERY_MATCH_TYPE_KEY)); - if (matchType != QueryMatchType.NONE) { - var finalOutput = mergeResponses(responses, matchType); - rb.rsp.add(MONITOR_OUTPUT_KEY, finalOutput); - } + var finalOutput = QueryMatchResponseCodec.mergeResponses(responses); + rb.rsp.add(MONITOR_OUTPUT_KEY, finalOutput); } @Override diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java index e16ce2c481c5..8ce779e0c8bd 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java @@ -24,7 +24,6 @@ import java.util.function.Function; import org.apache.lucene.monitor.CandidateMatcher; import org.apache.lucene.monitor.DocumentBatchVisitor; -import org.apache.lucene.monitor.HighlightsMatch; import org.apache.lucene.monitor.MultiMatchingQueries; import org.apache.lucene.monitor.QueryMatch; import org.apache.lucene.search.IndexSearcher; @@ -33,25 +32,12 @@ class SolrMatcherSinkFactory { SolrMatcherSinkFactory() {} - SolrMatcherSink build( - QueryMatchType matchType, - DocumentBatchVisitor documentBatch, - Map monitorResult) { - if (matchType == QueryMatchType.SIMPLE) { - return buildSimple( - documentBatch, - matchingQueries -> - QueryMatchResponseCodec.simpleEncode( - matchingQueries, monitorResult, documentBatch.size())); - } else if (matchType == QueryMatchType.HIGHLIGHTS) { - return build( - documentBatch, - HighlightsMatch.MATCHER::createMatcher, - matchingQueries -> - QueryMatchResponseCodec.highlightEncode( - matchingQueries, monitorResult, documentBatch.size())); - } - return buildSimple(documentBatch, __ -> {}); + SolrMatcherSink build(DocumentBatchVisitor documentBatch, Map monitorResult) { + return buildSimple( + documentBatch, + matchingQueries -> + QueryMatchResponseCodec.simpleEncode( + matchingQueries, monitorResult, documentBatch.size())); } private SolrMatcherSink buildSimple( diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java index f4a8583ac859..051cb7297056 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java @@ -22,7 +22,6 @@ import java.io.IOException; import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.monitor.QCEVisitor; -import org.apache.lucene.search.ConstantScoreQuery; import org.apache.lucene.search.ScoreMode; import org.apache.solr.monitor.MonitorDataValues; import org.apache.solr.monitor.SolrMonitorQueryDecoder; @@ -36,14 +35,12 @@ class SolrMonitorQueryCollector extends DelegatingCollector { private final SolrMatcherSink matcherSink; private final MonitorDataValues dataValues = new MonitorDataValues(); private final boolean writeToDocList; - private final QueryMatchType queryMatchType; SolrMonitorQueryCollector(CollectorContext collectorContext) { this.monitorQueryCache = collectorContext.queryCache; this.queryDecoder = collectorContext.queryDecoder; this.matcherSink = collectorContext.solrMatcherSink; this.writeToDocList = collectorContext.writeToDocList; - this.queryMatchType = collectorContext.queryMatchType; } @Override @@ -52,10 +49,11 @@ public void collect(int doc) throws IOException { var entry = getEntry(dataValues); var queryId = dataValues.getQueryId(); var originalMatchQuery = entry.getMatchQuery(); - var matchQuery = - queryMatchType.needsScores - ? originalMatchQuery - : new ConstantScoreQuery(originalMatchQuery); + + var matchQuery = originalMatchQuery; + // TODO: or should this be wrapped like this? + // var matchQuery = new ConstantScoreQuery(originalMatchQuery); + boolean isMatch = matcherSink.matchQuery(queryId, matchQuery, entry.getMetadata()); if (isMatch && writeToDocList) { super.collect(doc); @@ -95,19 +93,16 @@ static class CollectorContext { private final SolrMonitorQueryDecoder queryDecoder; private final SolrMatcherSink solrMatcherSink; private final boolean writeToDocList; - private final QueryMatchType queryMatchType; CollectorContext( MonitorQueryCache queryCache, SolrMonitorQueryDecoder queryDecoder, SolrMatcherSink solrMatcherSink, - boolean writeToDocList, - QueryMatchType queryMatchType) { + boolean writeToDocList) { this.queryCache = queryCache; this.queryDecoder = queryDecoder; this.solrMatcherSink = solrMatcherSink; this.writeToDocList = writeToDocList; - this.queryMatchType = queryMatchType; } } } diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java index 276cd78e728b..3a9115af5d93 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java @@ -22,7 +22,6 @@ import static org.apache.solr.monitor.MonitorConstants.MONITOR_DOCUMENTS_KEY; import static org.apache.solr.monitor.MonitorConstants.MONITOR_OUTPUT_KEY; import static org.apache.solr.monitor.MonitorConstants.MONITOR_QUERIES_KEY; -import static org.apache.solr.monitor.MonitorConstants.QUERY_MATCH_TYPE_KEY; import static org.apache.solr.monitor.MonitorConstants.WRITE_TO_DOC_LIST_KEY; import java.io.IOException; @@ -31,11 +30,8 @@ import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; -import java.util.ArrayList; -import java.util.LinkedHashMap; import java.util.List; import java.util.Map; -import org.apache.lucene.monitor.HighlightsMatch; import org.apache.lucene.monitor.MonitorFields; import org.apache.solr.BaseDistributedSearchTestCase; import org.apache.solr.client.solrj.response.QueryResponse; @@ -73,9 +69,7 @@ public void testMonitorQuery() throws Exception { CommonParams.JSON, read("/monitor/multi-doc-batch.json"), CommonParams.QT, - "/reverseSearch", - QUERY_MATCH_TYPE_KEY, - "simple" + "/reverseSearch" }; QueryResponse response = query(params); System.out.println("Response = " + response); @@ -107,9 +101,7 @@ public void testMonitorQuery() throws Exception { CommonParams.QT, "/reverseSearch", WRITE_TO_DOC_LIST_KEY, - writeToDocList, - QUERY_MATCH_TYPE_KEY, - "simple" + writeToDocList }; response = query(params); System.out.println("Response = " + response); @@ -152,9 +144,7 @@ public void testNoDocListInResponse() throws Exception { CommonParams.QT, "/reverseSearch", WRITE_TO_DOC_LIST_KEY, - writeToDocList, - QUERY_MATCH_TYPE_KEY, - "simple" + writeToDocList }; QueryResponse response = query(params); System.out.println("Response = " + response); @@ -183,9 +173,7 @@ public void testDefaultParser() throws Exception { CommonParams.QT, "/reverseSearch", WRITE_TO_DOC_LIST_KEY, - writeToDocList, - QUERY_MATCH_TYPE_KEY, - "simple" + writeToDocList }; QueryResponse response = query(params); @@ -222,9 +210,7 @@ public void testDisjunctionQuery() throws Exception { CommonParams.QT, "/reverseSearch", WRITE_TO_DOC_LIST_KEY, - writeToDocList, - QUERY_MATCH_TYPE_KEY, - "simple" + writeToDocList }; QueryResponse response = query(params); @@ -257,9 +243,7 @@ public void testNoDanglingDecomposition() throws Exception { CommonParams.QT, "/reverseSearch", WRITE_TO_DOC_LIST_KEY, - writeToDocList, - QUERY_MATCH_TYPE_KEY, - "simple" + writeToDocList }; QueryResponse response = query(params); @@ -306,9 +290,7 @@ public void testNotQuery() throws Exception { CommonParams.QT, "/reverseSearch", WRITE_TO_DOC_LIST_KEY, - writeToDocList, - QUERY_MATCH_TYPE_KEY, - "simple" + writeToDocList }; QueryResponse response = query(params); @@ -338,9 +320,7 @@ public void testWildCardQuery() throws Exception { CommonParams.QT, "/reverseSearch", WRITE_TO_DOC_LIST_KEY, - writeToDocList, - QUERY_MATCH_TYPE_KEY, - "simple" + writeToDocList }; QueryResponse response = query(params); @@ -352,168 +332,6 @@ public void testWildCardQuery() throws Exception { validate(response, 4, List.of("0", "1", "2"), writeToDocList); } - @Test - @ShardsFixed(num = 2) - public void testDefaultQueryMatchTypeIsNone() 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); - - final boolean writeToDocList = supportsWriteToDocList(); - Object[] params = - new Object[] { - CommonParams.SORT, - id + " desc", - CommonParams.JSON, - read("/monitor/multi-doc-batch.json"), - CommonParams.QT, - "/reverseSearch", - WRITE_TO_DOC_LIST_KEY, - writeToDocList - }; - - QueryResponse response = query(params); - System.out.println("Response = " + response); - if (writeToDocList) { - assertEquals(2, ((SolrDocumentList) response.getResponse().get("response")).size()); - } - assertNull(response.getResponse().get(MONITOR_OUTPUT_KEY)); - } - - @Test - @ShardsFixed(num = 2) - public void testMultiDocHighlightMatchType() throws Exception { - index( - id, - Integer.toString(0), - MonitorFields.MONITOR_QUERY, - "content0_offset_s:\"elevator stairs\""); - index( - id, - Integer.toString(1), - MonitorFields.MONITOR_QUERY, - "content0_offset_sds:highlights && content0_offset_sds:field && content0_offset_s:elevator"); - index( - id, - Integer.toString(2), - MonitorFields.MONITOR_QUERY, - "content0_offset_sds:ignore && content0_offset_sds:field && content0_offset_s:elevator"); - index( - id, - Integer.toString(3), - MonitorFields.MONITOR_QUERY, - "content0_offset_sds:highlights && content0_offset_sds:ignore && content0_offset_s:elevator"); - index(id, Integer.toString(4), MonitorFields.MONITOR_QUERY, "content0_offset_s:elevator"); - commit(); - handle.clear(); - handle.put("responseHeader", SKIP); - handle.put("response", SKIP); - - final boolean writeToDocList = supportsWriteToDocList(); - Object[] params = - new Object[] { - CommonParams.SORT, - id + " desc", - CommonParams.JSON, - read("/monitor/multi-doc-batch-multi-valued.json"), - CommonParams.QT, - "/reverseSearch", - QUERY_MATCH_TYPE_KEY, - "highlights", - WRITE_TO_DOC_LIST_KEY, - writeToDocList - }; - - QueryResponse response = query(params); - System.out.println("Response = " + response); - String f1 = "content0_offset_s"; - String f2 = "content0_offset_sds"; - - Map queryMatch0 = - queryMatch("0", f1, List.of(new HighlightsMatch.Hit(0, 0, 1, 15)), f2, List.of()); - Map queryMatch1 = - queryMatch( - "1", - f1, - List.of(new HighlightsMatch.Hit(0, 0, 0, 8)), - f2, - List.of( - new HighlightsMatch.Hit(1, 5, 1, 15), new HighlightsMatch.Hit(106, 38, 106, 43))); - Map queryMatch4 = - queryMatch("4", f1, List.of(new HighlightsMatch.Hit(0, 0, 0, 8)), f2, List.of()); - validate(response, 0, List.of(queryMatch0, queryMatch1, queryMatch4), writeToDocList); - queryMatch4 = queryMatch("4", f1, List.of(new HighlightsMatch.Hit(2, 7, 2, 15)), f2, List.of()); - validate(response, 1, List.of(queryMatch4), writeToDocList); - var queries = monitorQueries(response, 0); - assertEquals(3, queries.size()); - queries = monitorQueries(response, 1); - assertEquals(1, queries.size()); - if (writeToDocList) { - assertEquals(3, ((SolrDocumentList) response.getResponse().get("response")).size()); - } - } - - @Test - public void testHighlightMatchType() throws Exception { - index(id, Integer.toString(0), MonitorFields.MONITOR_QUERY, "content0_s:\"elevator stairs\""); - index( - id, - Integer.toString(1), - MonitorFields.MONITOR_QUERY, - "content0_sds:highlights || content0_sds:field || content0_s:elevator"); - index( - id, - Integer.toString(2), - MonitorFields.MONITOR_QUERY, - "content0_sds:ignore && content0_sds:field && content0_s:elevator"); - commit(); - handle.clear(); - handle.put("responseHeader", SKIP); - handle.put("response", SKIP); - - final boolean writeToDocList = supportsWriteToDocList(); - Object[] params = - new Object[] { - CommonParams.SORT, - id + " desc", - CommonParams.JSON, - read("/monitor/single-doc-batch-multi-valued.json"), - CommonParams.QT, - "/reverseSearch", - QUERY_MATCH_TYPE_KEY, - "highlights", - WRITE_TO_DOC_LIST_KEY, - writeToDocList - }; - - QueryResponse response = query(params); - System.out.println("Response = " + response); - String f1 = "content0_s"; - String f2 = "content0_sds"; - - Map queryMatch0 = - queryMatch("0", f1, List.of(new HighlightsMatch.Hit(0, 0, 1, 15)), f2, List.of()); - Map queryMatch1 = - queryMatch( - "1", - f1, - List.of(new HighlightsMatch.Hit(0, 0, 0, 8)), - f2, - List.of( - new HighlightsMatch.Hit(1, 5, 1, 15), new HighlightsMatch.Hit(106, 38, 106, 43))); - validate(response, 0, List.of(queryMatch0, queryMatch1), writeToDocList); - var queries = monitorQueries(response, 0); - assertEquals(2, queries.size()); - if (writeToDocList) { - // The disjuncts come in as separate matches - // TODO is this the most desirable behavior? - assertEquals(4, ((SolrDocumentList) response.getResponse().get("response")).size()); - } - } - @Test public void testDeleteByQueryId() throws Exception { index( @@ -536,9 +354,7 @@ public void testDeleteByQueryId() throws Exception { CommonParams.QT, "/reverseSearch", WRITE_TO_DOC_LIST_KEY, - writeToDocList, - QUERY_MATCH_TYPE_KEY, - "simple" + writeToDocList }; QueryResponse response = query(params); @@ -553,40 +369,6 @@ public void testDeleteByQueryId() throws Exception { assertEquals(0, ((SolrDocumentList) response.getResponse().get("response")).size()); } - static Map queryMatch( - String queryId, - String field1, - List firstFieldHits, - String field2, - List secondFieldHits) { - Map queryMatch = new LinkedHashMap<>(); - queryMatch.put(MonitorFields.QUERY_ID, queryId); - Map matchHits = new LinkedHashMap<>(); - var outHits1 = map(firstFieldHits); - if (!outHits1.isEmpty()) { - matchHits.put(field1, outHits1); - } - var outHits2 = map(secondFieldHits); - if (!outHits2.isEmpty()) { - matchHits.put(field2, outHits2); - } - queryMatch.put(MonitorConstants.HITS_KEY, matchHits); - return queryMatch; - } - - static List map(List hits) { - List outHits = new ArrayList<>(); - for (var hit : hits) { - Map hit00 = new LinkedHashMap<>(); - hit00.put("startPosition", hit.startPosition); - hit00.put("endPosition", hit.endPosition); - hit00.put("startOffset", hit.startOffset); - hit00.put("endOffset", hit.endOffset); - outHits.add(hit00); - } - return outHits; - } - void validate(QueryResponse response, int doc, Object expectedValue, boolean writeToDocList) { var monitorQueries = monitorQueries(response, doc); assertEquals(expectedValue, monitorQueries); diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java index 1557e2244445..337e9eb6bf52 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java @@ -19,7 +19,6 @@ package org.apache.solr.monitor; -import static org.apache.solr.monitor.MonitorConstants.QUERY_MATCH_TYPE_KEY; import static org.apache.solr.monitor.MonitorConstants.WRITE_TO_DOC_LIST_KEY; import java.net.URL; @@ -71,8 +70,6 @@ public void coexistWithRegularDocumentsTest() throws Exception { json, CommonParams.QT, "/reverseSearch", - QUERY_MATCH_TYPE_KEY, - "simple", WRITE_TO_DOC_LIST_KEY, "true" }; @@ -96,8 +93,6 @@ public void queryStringIdTest() throws Exception { json, CommonParams.QT, "/reverseSearch", - QUERY_MATCH_TYPE_KEY, - "simple", WRITE_TO_DOC_LIST_KEY, "true" }; @@ -162,14 +157,7 @@ public void multiPassPresearcherTest() throws Exception { String[] params = new String[] { - CommonParams.SORT, - "id desc", - CommonParams.JSON, - json, - CommonParams.QT, - "/reverseSearch", - QUERY_MATCH_TYPE_KEY, - "simple" + CommonParams.SORT, "id desc", CommonParams.JSON, json, CommonParams.QT, "/reverseSearch" }; assertQ( @@ -203,14 +191,7 @@ public void manySegmentsQuery() throws Exception { String[] params = new String[] { - CommonParams.SORT, - "id desc", - CommonParams.JSON, - json, - CommonParams.QT, - "/reverseSearch", - QUERY_MATCH_TYPE_KEY, - "simple" + CommonParams.SORT, "id desc", CommonParams.JSON, json, CommonParams.QT, "/reverseSearch" }; assertQ( From 483e46f5ff9229bb6925871f70500753be03bcb7 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Tue, 25 Jun 2024 08:18:34 -0400 Subject: [PATCH 46/85] always use ConstantScoreQuery Co-authored-by: Christine Poerschke --- .../apache/solr/monitor/search/SolrMonitorQueryCollector.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java index 051cb7297056..71a8d88ac535 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java @@ -50,9 +50,7 @@ public void collect(int doc) throws IOException { var queryId = dataValues.getQueryId(); var originalMatchQuery = entry.getMatchQuery(); - var matchQuery = originalMatchQuery; - // TODO: or should this be wrapped like this? - // var matchQuery = new ConstantScoreQuery(originalMatchQuery); + var matchQuery = new ConstantScoreQuery(originalMatchQuery); boolean isMatch = matcherSink.matchQuery(queryId, matchQuery, entry.getMetadata()); if (isMatch && writeToDocList) { From 28bf2641840f0dfe8f1076661e3387cb03135f7e Mon Sep 17 00:00:00 2001 From: Christine Poerschke Date: Mon, 1 Jul 2024 10:53:39 +0100 Subject: [PATCH 47/85] remove MonitorFields.ANYTOKEN_FIELD in favour of TermFilteredPresearcher.ANYTOKEN_FIELD (which is now accessible in Lucene 9.11.1) --- .../src/java/org/apache/lucene/monitor/MonitorFields.java | 1 - .../src/java/org/apache/solr/monitor/AliasingPresearcher.java | 4 ++-- .../apache/solr/monitor/search/ReverseSearchComponent.java | 4 ++-- 3 files changed, 4 insertions(+), 5 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java index 3972e28e81a9..7e064d677e7c 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java @@ -26,7 +26,6 @@ public 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 String ANYTOKEN_FIELD = TermFilteredPresearcher.ANYTOKEN_FIELD; public static final Set REQUIRED_MONITOR_SCHEMA_FIELDS = Set.of(QUERY_ID, CACHE_ID, MONITOR_QUERY); diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java index 9f2ea775d242..fe9d047b8b68 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java @@ -24,8 +24,8 @@ import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; import org.apache.lucene.index.LeafReader; -import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.monitor.Presearcher; +import org.apache.lucene.monitor.TermFilteredPresearcher; import org.apache.lucene.search.Query; import org.apache.lucene.util.BytesRef; @@ -71,7 +71,7 @@ public String getPrefix() { private Document alias(Document in) { Document out = new Document(); for (var field : in) { - if (!MonitorFields.ANYTOKEN_FIELD.equals(field.name()) + if (!TermFilteredPresearcher.ANYTOKEN_FIELD.equals(field.name()) && field instanceof Field && ((Field) field).tokenStreamValue() != null) { out.add( diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 962aaa9fc814..35bda3d7dd5e 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -208,10 +208,10 @@ public void inform(SolrCore core) { if (presearcher instanceof TermFilteredPresearcher || presearcher instanceof AliasingPresearcher) { - var anyTokenField = schema.getFieldOrNull(MonitorFields.ANYTOKEN_FIELD); + var anyTokenField = schema.getFieldOrNull(TermFilteredPresearcher.ANYTOKEN_FIELD); if (anyTokenField == null || !anyTokenField.tokenized() || !anyTokenField.multiValued()) { throw new IllegalStateException( - MonitorFields.ANYTOKEN_FIELD + " field must be tokenized and multi-valued."); + TermFilteredPresearcher.ANYTOKEN_FIELD + " field must be tokenized and multi-valued."); } } } From 13dffda6cd286b57365dd2cf02e9e41d1552ffca Mon Sep 17 00:00:00 2001 From: Christine Poerschke Date: Fri, 8 Nov 2024 11:42:28 +0000 Subject: [PATCH 48/85] add back inadvertently removed import --- .../apache/solr/monitor/search/SolrMonitorQueryCollector.java | 1 + 1 file changed, 1 insertion(+) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java index 71a8d88ac535..e95183de7cf5 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java @@ -22,6 +22,7 @@ import java.io.IOException; import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.monitor.QCEVisitor; +import org.apache.lucene.search.ConstantScoreQuery; import org.apache.lucene.search.ScoreMode; import org.apache.solr.monitor.MonitorDataValues; import org.apache.solr.monitor.SolrMonitorQueryDecoder; From cbf45de3317be43562c7e927995d02c8fc028392 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Mon, 11 Nov 2024 19:58:30 -0500 Subject: [PATCH 49/85] remove stand-alone monitor API --- .../handler/component/DebugComponent.java | 7 + .../reverse/ReverseSearchDebugInfo.java | 44 ++++ .../apache/solr/monitor/MonitorConstants.java | 5 - .../search/QueryMatchResponseCodec.java | 202 ------------------ .../search/ReverseSearchComponent.java | 32 +-- .../monitor/search/ReverseSearchHandler.java | 2 + .../search/SolrMatcherSinkFactory.java | 8 +- .../search/SolrMonitorQueryCollector.java | 12 +- .../monitor/src/test-files/monitor/doc0.json | 9 + .../monitor/src/test-files/monitor/doc1.json | 9 + .../monitor/src/test-files/monitor/doc2.json | 10 + ...ingle-doc-batch.json => elevator-doc.json} | 0 .../monitor/multi-doc-batch-multi-valued.json | 15 -- .../test-files/monitor/multi-doc-batch.json | 28 --- .../test-files/monitor/multi-value-doc.json | 11 + .../single-doc-batch-multi-valued.json | 11 - .../solr/monitor/MonitorSolrQueryTest.java | 201 +++++------------ .../monitor/SingleCoreMonitorSolrTest.java | 69 +++--- 18 files changed, 194 insertions(+), 481 deletions(-) create mode 100644 solr/core/src/java/org/apache/solr/search/reverse/ReverseSearchDebugInfo.java delete mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchResponseCodec.java create mode 100644 solr/modules/monitor/src/test-files/monitor/doc0.json create mode 100644 solr/modules/monitor/src/test-files/monitor/doc1.json create mode 100644 solr/modules/monitor/src/test-files/monitor/doc2.json rename solr/modules/monitor/src/test-files/monitor/{single-doc-batch.json => elevator-doc.json} (100%) delete mode 100644 solr/modules/monitor/src/test-files/monitor/multi-doc-batch-multi-valued.json delete mode 100644 solr/modules/monitor/src/test-files/monitor/multi-doc-batch.json create mode 100644 solr/modules/monitor/src/test-files/monitor/multi-value-doc.json delete mode 100644 solr/modules/monitor/src/test-files/monitor/single-doc-batch-multi-valued.json 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 0565290cf069..0d3091e08e60 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 @@ -40,6 +40,7 @@ import org.apache.solr.search.QueryParsing; import org.apache.solr.search.SolrIndexSearcher; import org.apache.solr.search.facet.FacetDebugInfo; +import org.apache.solr.search.reverse.ReverseSearchDebugInfo; import org.apache.solr.search.stats.StatsCache; import org.apache.solr.util.SolrPluginUtils; import org.apache.solr.util.SolrResponseUtil; @@ -115,6 +116,12 @@ public void process(ResponseBuilder rb) throws IOException { info.add("facet-debug", fdebug.getFacetDebugInfo()); } + ReverseSearchDebugInfo rsdebug = + (ReverseSearchDebugInfo) (rb.req.getContext().get(ReverseSearchDebugInfo.KEY)); + if (rsdebug != null) { + info.add("reverse-search-debug", rsdebug.getReverseSearchDebugInfo()); + } + if (rb.req.getJSON() != null) { info.add(JSON, rb.req.getJSON()); } diff --git a/solr/core/src/java/org/apache/solr/search/reverse/ReverseSearchDebugInfo.java b/solr/core/src/java/org/apache/solr/search/reverse/ReverseSearchDebugInfo.java new file mode 100644 index 000000000000..87cbaf58e2e3 --- /dev/null +++ b/solr/core/src/java/org/apache/solr/search/reverse/ReverseSearchDebugInfo.java @@ -0,0 +1,44 @@ +/* + * + * * 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.search.reverse; + +import org.apache.solr.common.util.SimpleOrderedMap; + +public class ReverseSearchDebugInfo { + + public static final String KEY = ReverseSearchDebugInfo.class.getSimpleName(); + + private final int queriesRun; + + public ReverseSearchDebugInfo(int queriesRun) { + this.queriesRun = queriesRun; + } + + public int getQueriesRun() { + return queriesRun; + } + + public SimpleOrderedMap getReverseSearchDebugInfo() { + SimpleOrderedMap info = new SimpleOrderedMap<>(); + + info.add("queriesRun", queriesRun); + return info; + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java index 756097fc663e..60719e6c2db8 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java @@ -24,9 +24,4 @@ public class MonitorConstants { private MonitorConstants() {} public static final String MONITOR_DOCUMENTS_KEY = "monitorDocuments"; - public static final String MONITOR_DOCUMENT_KEY = "monitorDocument"; - public static final String MONITOR_QUERIES_KEY = "queries"; - public static final String MONITOR_QUERIES_RUN = "queriesRun"; - public static final String MONITOR_OUTPUT_KEY = "monitor"; - public static final String WRITE_TO_DOC_LIST_KEY = "writeToDocList"; } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchResponseCodec.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchResponseCodec.java deleted file mode 100644 index 3d169fbd24e3..000000000000 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/QueryMatchResponseCodec.java +++ /dev/null @@ -1,202 +0,0 @@ -/* - * - * * 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.monitor.search; - -import static org.apache.solr.monitor.MonitorConstants.MONITOR_DOCUMENTS_KEY; -import static org.apache.solr.monitor.MonitorConstants.MONITOR_DOCUMENT_KEY; -import static org.apache.solr.monitor.MonitorConstants.MONITOR_OUTPUT_KEY; -import static org.apache.solr.monitor.MonitorConstants.MONITOR_QUERIES_KEY; -import static org.apache.solr.monitor.MonitorConstants.MONITOR_QUERIES_RUN; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.function.Function; -import java.util.stream.Collectors; -import java.util.stream.IntStream; -import java.util.stream.Stream; -import org.apache.lucene.monitor.MultiMatchingQueries; -import org.apache.lucene.monitor.QueryMatch; -import org.apache.lucene.util.BytesRef; -import org.apache.solr.common.SolrException; -import org.apache.solr.common.util.NamedList; - -@SuppressWarnings("unchecked") -class QueryMatchResponseCodec { - - static Map mergeResponses(List> responses) { - Map> wrappedMerged = new HashMap<>(); - int queriesRun = 0; - for (var response : responses) { - Object smq = response.get(MONITOR_OUTPUT_KEY); - if (!(smq instanceof Map)) { - throw new SolrException( - SolrException.ErrorCode.BAD_REQUEST, MONITOR_OUTPUT_KEY + " must be a map"); - } - Map singleMonitorOutput = (Map) smq; - decodeToWrappers(singleMonitorOutput, wrappedMerged); - var delta = singleMonitorOutput.get(MONITOR_QUERIES_RUN); - if (!(delta instanceof Integer)) { - throw new SolrException( - SolrException.ErrorCode.BAD_REQUEST, MONITOR_QUERIES_RUN + " must be an integer"); - } - queriesRun += (Integer) delta; - } - - for (var mergedValues : wrappedMerged.values()) { - Collections.sort(mergedValues); - } - Map finalDocOutputs = - wrappedMerged.entrySet().stream() - .collect( - Collectors.toMap( - Map.Entry::getKey, - entry -> encodeWrappers(entry.getValue().stream(), entry.getKey()))); - Map output = new HashMap<>(); - output.put(MONITOR_DOCUMENTS_KEY, finalDocOutputs); - output.put(MONITOR_QUERIES_RUN, queriesRun); - return output; - } - - private static void decodeToWrappers( - Object object, Map> output) { - if (!(object instanceof Map)) { - throw new IllegalArgumentException("input object should be a map"); - } - Map docLevelMQResponse = (Map) object; - Object monitorDocumentsRaw = docLevelMQResponse.get(MONITOR_DOCUMENTS_KEY); - if (!(monitorDocumentsRaw instanceof Map)) { - throw new IllegalArgumentException(MONITOR_DOCUMENTS_KEY + " should be a map"); - } - var monitorDocuments = (Map) monitorDocumentsRaw; - for (var docEntryRaw : monitorDocuments.values()) { - if (!(docEntryRaw instanceof Map)) { - throw new IllegalArgumentException(MONITOR_DOCUMENTS_KEY + " should contain maps"); - } - var docEntry = (Map) docEntryRaw; - Object docRaw = docEntry.get(MONITOR_DOCUMENT_KEY); - if (!(docRaw instanceof Integer)) { - throw new IllegalStateException(MONITOR_DOCUMENT_KEY + " needs to be an int"); - } - Object monitorQueriesRaw = docEntry.get(MONITOR_QUERIES_KEY); - if (!(monitorQueriesRaw instanceof List)) { - throw new IllegalStateException(MONITOR_QUERIES_KEY + " needs to be an list"); - } - int doc = (Integer) docRaw; - List wrappers = output.computeIfAbsent(doc, i -> new ArrayList<>()); - List serializableFormMQs = (List) monitorQueriesRaw; - serializableFormMQs.forEach( - serializableForm -> - wrappers.add(SimpleQueryMatchWrapper.fromSerializableForm(serializableForm))); - } - } - - static void simpleEncode( - MultiMatchingQueries matchingQueries, - Map output, - int docBatchSize) { - encodeMultiMatchingQuery( - matchingQueries, output, docBatchSize, SimpleQueryMatchWrapper::fromQueryMatch); - } - - private static void encodeMultiMatchingQuery( - MultiMatchingQueries matchingQueries, - Map output, - int docBatchSize, - Function wrappingFunction) { - if (matchingQueries.getBatchSize() != docBatchSize) { - throw new IllegalArgumentException("output size doesn't match document batch size"); - } - Map docOutputs = - IntStream.range(0, matchingQueries.getBatchSize()) - .mapToObj( - doc -> - encodeWrappers( - matchingQueries.getMatches(doc).stream().map(wrappingFunction), doc)) - .collect( - Collectors.toMap( - wrapper -> (Integer) wrapper.get(MONITOR_DOCUMENT_KEY), Function.identity())); - output.put(MONITOR_DOCUMENTS_KEY, docOutputs); - output.put(MONITOR_QUERIES_RUN, matchingQueries.getQueriesRun()); - } - - private static Map encodeWrappers(Stream matches, int doc) { - Map map = new LinkedHashMap<>(); - map.put(MONITOR_DOCUMENT_KEY, doc); - map.put( - MONITOR_QUERIES_KEY, - matches.sorted().map(QueryMatchWrapper::toSerializableForm).collect(Collectors.toList())); - return map; - } - - private interface QueryMatchWrapper extends Comparable { - - Object toSerializableForm(); - - BytesRef queryId(); - - @Override - default int compareTo(QueryMatchWrapper o) { - if (getClass() != o.getClass()) { - throw new IllegalArgumentException( - getClass().getSimpleName() - + " can only be compared to other instances of the same concrete type"); - } - return queryId().compareTo(o.queryId()); - } - } - - static void decodingError(Object obj, Class wrapper) { - throw new IllegalArgumentException("Cannot decode " + obj + " to " + wrapper.getSimpleName()); - } - - private static class SimpleQueryMatchWrapper implements QueryMatchWrapper { - - private final BytesRef queryId; - - private SimpleQueryMatchWrapper(BytesRef queryId) { - this.queryId = queryId; - } - - private static SimpleQueryMatchWrapper fromQueryMatch(QueryMatch queryMatch) { - return new SimpleQueryMatchWrapper(new BytesRef(queryMatch.getQueryId())); - } - - private static SimpleQueryMatchWrapper fromSerializableForm(Object serializableForm) { - if (!(serializableForm instanceof String)) { - decodingError(serializableForm, SimpleQueryMatchWrapper.class); - } - return new SimpleQueryMatchWrapper(new BytesRef((String) serializableForm)); - } - - @Override - public Object toSerializableForm() { - return queryId.utf8ToString(); - } - - @Override - public BytesRef queryId() { - return queryId; - } - } -} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index c241ba200b9e..7bc3db1db7fe 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -20,19 +20,16 @@ package org.apache.solr.monitor.search; import static org.apache.solr.monitor.MonitorConstants.MONITOR_DOCUMENTS_KEY; -import static org.apache.solr.monitor.MonitorConstants.MONITOR_OUTPUT_KEY; -import static org.apache.solr.monitor.MonitorConstants.WRITE_TO_DOC_LIST_KEY; import static org.apache.solr.monitor.search.PresearcherFactory.DEFAULT_ALIAS_PREFIX; import java.util.ArrayList; import java.util.Arrays; import java.util.Comparator; -import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Optional; +import java.util.UUID; import java.util.function.BiPredicate; -import java.util.stream.Collectors; import org.apache.lucene.document.Document; import org.apache.lucene.monitor.DocumentBatchVisitor; import org.apache.lucene.monitor.MonitorFields; @@ -47,7 +44,6 @@ import org.apache.solr.core.SolrCore; import org.apache.solr.handler.component.QueryComponent; import org.apache.solr.handler.component.ResponseBuilder; -import org.apache.solr.handler.component.ShardRequest; import org.apache.solr.handler.loader.JsonLoader; import org.apache.solr.monitor.AliasingPresearcher; import org.apache.solr.monitor.SolrMonitorQueryDecoder; @@ -62,7 +58,6 @@ public class ReverseSearchComponent extends QueryComponent implements SolrCoreAware { public static final String COMPONENT_NAME = "reverseSearch"; - private static final String MATCHER_THREAD_COUNT_KEY = "threadCount"; private static final String SOLR_MONITOR_CACHE_NAME_KEY = "solrMonitorCacheName"; private static final String SOLR_MONITOR_CACHE_NAME_DEFAULT = "solrMonitorCache"; @@ -88,9 +83,7 @@ public void init(NamedList args) { public void prepare(ResponseBuilder rb) { var req = rb.req; var documentBatch = documentBatch(req); - boolean writeToDocList = req.getParams().getBool(WRITE_TO_DOC_LIST_KEY, false); - Map monitorResult = new HashMap<>(); - var matcherSink = solrMatcherSinkFactory.build(documentBatch, monitorResult); + var matcherSink = solrMatcherSinkFactory.build(documentBatch, rb.req.getContext()); Query preFilterQuery = presearcher.buildQuery(documentBatch.get(), getTermAcceptor(rb.req)); List mutableFilters = Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); @@ -103,9 +96,8 @@ public void prepare(ResponseBuilder rb) { mutableFilters.add( new MonitorPostFilter( new SolrMonitorQueryCollector.CollectorContext( - solrMonitorCache, queryDecoder, matcherSink, writeToDocList))); + solrMonitorCache, queryDecoder, matcherSink))); rb.setFilters(mutableFilters); - rb.rsp.add(MONITOR_OUTPUT_KEY, monitorResult); } @SuppressWarnings({"unchecked"}) @@ -120,12 +112,16 @@ private DocumentBatchVisitor documentBatch(SolrQueryRequest req) { throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "need documents list"); } List luceneDocs = new ArrayList<>(); + int i = 0; for (var 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"); } + var docAsMap = (Map) document; + docAsMap.putIfAbsent( + req.getSchema().getUniqueKeyField().getName(), UUID.randomUUID().toString()); var solrInputDoc = JsonLoader.buildDoc((Map) document); var luceneDoc = DocumentBuilder.toDocument(solrInputDoc, req.getSchema()); luceneDocs.add(luceneDoc); @@ -133,20 +129,6 @@ private DocumentBatchVisitor documentBatch(SolrQueryRequest req) { return DocumentBatchVisitor.of(req.getSchema().getIndexAnalyzer(), luceneDocs); } - @Override - public void handleResponses(ResponseBuilder rb, ShardRequest sreq) { - if ((sreq.purpose & ShardRequest.PURPOSE_GET_TOP_IDS) == 0) { - return; - } - var responses = - sreq.responses.stream() - .map(shardResponse -> shardResponse.getSolrResponse().getResponse()) - .collect(Collectors.toList()); - rb.rsp.getValues().removeAll(MONITOR_OUTPUT_KEY); - var finalOutput = QueryMatchResponseCodec.mergeResponses(responses); - rb.rsp.add(MONITOR_OUTPUT_KEY, finalOutput); - } - @Override public String getDescription() { return "Component that integrates with lucene monitor for reverse search."; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java index 64e8827fb4c0..f6d66471c8c5 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java @@ -21,6 +21,7 @@ import java.util.ArrayList; import java.util.List; +import org.apache.solr.handler.component.DebugComponent; import org.apache.solr.handler.component.QueryComponent; import org.apache.solr.handler.component.SearchHandler; @@ -31,6 +32,7 @@ protected List getDefaultComponents() { ArrayList names = new ArrayList<>(2); names.add(QueryComponent.COMPONENT_NAME); names.add(ReverseSearchComponent.COMPONENT_NAME); + names.add(DebugComponent.COMPONENT_NAME); return names; } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java index 8ce779e0c8bd..21b0df05f665 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java @@ -27,17 +27,19 @@ import org.apache.lucene.monitor.MultiMatchingQueries; import org.apache.lucene.monitor.QueryMatch; import org.apache.lucene.search.IndexSearcher; +import org.apache.solr.search.reverse.ReverseSearchDebugInfo; class SolrMatcherSinkFactory { SolrMatcherSinkFactory() {} - SolrMatcherSink build(DocumentBatchVisitor documentBatch, Map monitorResult) { + SolrMatcherSink build(DocumentBatchVisitor documentBatch, Map reqContext) { return buildSimple( documentBatch, matchingQueries -> - QueryMatchResponseCodec.simpleEncode( - matchingQueries, monitorResult, documentBatch.size())); + reqContext.put( + ReverseSearchDebugInfo.KEY, + new ReverseSearchDebugInfo(matchingQueries.getQueriesRun()))); } private SolrMatcherSink buildSimple( diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java index 71a8d88ac535..9b570a5b0327 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java @@ -22,6 +22,7 @@ import java.io.IOException; import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.monitor.QCEVisitor; +import org.apache.lucene.search.ConstantScoreQuery; import org.apache.lucene.search.ScoreMode; import org.apache.solr.monitor.MonitorDataValues; import org.apache.solr.monitor.SolrMonitorQueryDecoder; @@ -34,13 +35,12 @@ class SolrMonitorQueryCollector extends DelegatingCollector { private final SolrMonitorQueryDecoder queryDecoder; private final SolrMatcherSink matcherSink; private final MonitorDataValues dataValues = new MonitorDataValues(); - private final boolean writeToDocList; + private String lastQueryId; SolrMonitorQueryCollector(CollectorContext collectorContext) { this.monitorQueryCache = collectorContext.queryCache; this.queryDecoder = collectorContext.queryDecoder; this.matcherSink = collectorContext.solrMatcherSink; - this.writeToDocList = collectorContext.writeToDocList; } @Override @@ -53,7 +53,8 @@ public void collect(int doc) throws IOException { var matchQuery = new ConstantScoreQuery(originalMatchQuery); boolean isMatch = matcherSink.matchQuery(queryId, matchQuery, entry.getMetadata()); - if (isMatch && writeToDocList) { + if (isMatch && !queryId.equals(lastQueryId)) { + lastQueryId = queryId; super.collect(doc); } } @@ -90,17 +91,14 @@ static class CollectorContext { private final MonitorQueryCache queryCache; private final SolrMonitorQueryDecoder queryDecoder; private final SolrMatcherSink solrMatcherSink; - private final boolean writeToDocList; CollectorContext( MonitorQueryCache queryCache, SolrMonitorQueryDecoder queryDecoder, - SolrMatcherSink solrMatcherSink, - boolean writeToDocList) { + SolrMatcherSink solrMatcherSink) { this.queryCache = queryCache; this.queryDecoder = queryDecoder; this.solrMatcherSink = solrMatcherSink; - this.writeToDocList = writeToDocList; } } } diff --git a/solr/modules/monitor/src/test-files/monitor/doc0.json b/solr/modules/monitor/src/test-files/monitor/doc0.json new file mode 100644 index 000000000000..ca9e136e5bc5 --- /dev/null +++ b/solr/modules/monitor/src/test-files/monitor/doc0.json @@ -0,0 +1,9 @@ +{ + "params": { + "monitorDocuments": [ + { + "content_s": "elevator stairs" + } + ] + } +} \ No newline at end of file diff --git a/solr/modules/monitor/src/test-files/monitor/doc1.json b/solr/modules/monitor/src/test-files/monitor/doc1.json new file mode 100644 index 000000000000..7dbcd20bccae --- /dev/null +++ b/solr/modules/monitor/src/test-files/monitor/doc1.json @@ -0,0 +1,9 @@ +{ + "params": { + "monitorDocuments": [ + { + "content_s": "something else" + } + ] + } +} \ No newline at end of file diff --git a/solr/modules/monitor/src/test-files/monitor/doc2.json b/solr/modules/monitor/src/test-files/monitor/doc2.json new file mode 100644 index 000000000000..9ce2cb2a549d --- /dev/null +++ b/solr/modules/monitor/src/test-files/monitor/doc2.json @@ -0,0 +1,10 @@ +{ + "params": { + "monitorDocuments": [ + { + "content_s": "more weird content", + "other_content_s": "solr is cool" + } + ] + } +} \ No newline at end of file diff --git a/solr/modules/monitor/src/test-files/monitor/single-doc-batch.json b/solr/modules/monitor/src/test-files/monitor/elevator-doc.json similarity index 100% rename from solr/modules/monitor/src/test-files/monitor/single-doc-batch.json rename to solr/modules/monitor/src/test-files/monitor/elevator-doc.json diff --git a/solr/modules/monitor/src/test-files/monitor/multi-doc-batch-multi-valued.json b/solr/modules/monitor/src/test-files/monitor/multi-doc-batch-multi-valued.json deleted file mode 100644 index a5d666aa6ef8..000000000000 --- a/solr/modules/monitor/src/test-files/monitor/multi-doc-batch-multi-valued.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "params": { - "monitorDocuments": [ - { - "id": "0", - "content0_offset_s": "elevator stairs", - "content0_offset_sds": ["test highlights", " on this multi-valued field"] - }, - { - "id": "1", - "content0_offset_s": "on the elevator " - } - ] - } -} \ No newline at end of file diff --git a/solr/modules/monitor/src/test-files/monitor/multi-doc-batch.json b/solr/modules/monitor/src/test-files/monitor/multi-doc-batch.json deleted file mode 100644 index c22064ef098b..000000000000 --- a/solr/modules/monitor/src/test-files/monitor/multi-doc-batch.json +++ /dev/null @@ -1,28 +0,0 @@ -{ - "params": { - "monitorDocuments": [ - { - "id": "0", - "content_s": "elevator stairs" - }, - { - "id": "1", - "content_s": "something else" - }, - { - "id": "2", - "content_s": "more weird content", - "other_content_s": "solr is cool" - }, - { - "id": "3", - "content_s": "test test test", - "other_content_s": "I'm tired" - }, - { - "id": "4", - "content_s": "test test test" - } - ] - } -} \ No newline at end of file diff --git a/solr/modules/monitor/src/test-files/monitor/multi-value-doc.json b/solr/modules/monitor/src/test-files/monitor/multi-value-doc.json new file mode 100644 index 000000000000..29a35916a906 --- /dev/null +++ b/solr/modules/monitor/src/test-files/monitor/multi-value-doc.json @@ -0,0 +1,11 @@ +{ + "params": { + "monitorDocuments": [ + { + "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/monitor/src/test-files/monitor/single-doc-batch-multi-valued.json b/solr/modules/monitor/src/test-files/monitor/single-doc-batch-multi-valued.json deleted file mode 100644 index 323377476ddf..000000000000 --- a/solr/modules/monitor/src/test-files/monitor/single-doc-batch-multi-valued.json +++ /dev/null @@ -1,11 +0,0 @@ -{ - "params": { - "monitorDocuments": [ - { - "id": "0", - "content0_s": "elevator stairs", - "content0_sds": ["test highlights", " on this multi-valued field"] - } - ] - } -} \ No newline at end of file diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java index 3a9115af5d93..ad3167290848 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java @@ -19,11 +19,6 @@ package org.apache.solr.monitor; -import static org.apache.solr.monitor.MonitorConstants.MONITOR_DOCUMENTS_KEY; -import static org.apache.solr.monitor.MonitorConstants.MONITOR_OUTPUT_KEY; -import static org.apache.solr.monitor.MonitorConstants.MONITOR_QUERIES_KEY; -import static org.apache.solr.monitor.MonitorConstants.WRITE_TO_DOC_LIST_KEY; - import java.io.IOException; import java.net.URISyntaxException; import java.net.URL; @@ -31,7 +26,6 @@ import java.nio.file.Files; import java.nio.file.Path; import java.util.List; -import java.util.Map; import org.apache.lucene.monitor.MonitorFields; import org.apache.solr.BaseDistributedSearchTestCase; import org.apache.solr.client.solrj.response.QueryResponse; @@ -43,7 +37,6 @@ public class MonitorSolrQueryTest extends BaseDistributedSearchTestCase { @Test - @ShardsFixed(num = 3) public void testMonitorQuery() throws Exception { index(id, Integer.toString(0), MonitorFields.MONITOR_QUERY, "content_s:\"elevator music\""); index( @@ -67,91 +60,73 @@ public void testMonitorQuery() throws Exception { CommonParams.SORT, MonitorFields.QUERY_ID + " desc", CommonParams.JSON, - read("/monitor/multi-doc-batch.json"), + read("/monitor/doc1.json"), CommonParams.QT, "/reverseSearch" }; QueryResponse response = query(params); System.out.println("Response = " + response); - validate(response, 0, List.of("1", "4"), false); - validate(response, 1, List.of("7"), false); - validate(response, 2, List.of("5"), false); - assertEquals(0, ((SolrDocumentList) response.getResponse().get("response")).size()); + validateDocList(response, List.of("7")); + } - 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\""); + @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 hill"); - index(id, Integer.toString(2), MonitorFields.MONITOR_QUERY, "content_s:elevator"); + "{!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); - final boolean writeToDocList = supportsWriteToDocList(); - params = + Object[] params = new Object[] { CommonParams.SORT, - id + " desc", + MonitorFields.QUERY_ID + " desc", CommonParams.JSON, - read("/monitor/multi-doc-batch.json"), + read("/monitor/doc0.json"), CommonParams.QT, - "/reverseSearch", - WRITE_TO_DOC_LIST_KEY, - writeToDocList + "/reverseSearch" }; - response = query(params); + QueryResponse response = query(params); System.out.println("Response = " + response); - validate(response, 0, 0, "2", writeToDocList); - validate(response, 0, 1, "4", writeToDocList); - validate(response, 1, 0, "7", writeToDocList); - validate(response, 2, 0, "6", writeToDocList); - if (writeToDocList) { - assertEquals(4, ((SolrDocumentList) response.getResponse().get("response")).size()); - } - } + validateDocList(response, List.of("4", "1")); + assertEquals(2, ((SolrDocumentList) response.getResponse().get("response")).size()); - @Test - @ShardsFixed(num = 3) - public void testNoDocListInResponse() throws Exception { - index(id, Integer.toString(0), MonitorFields.MONITOR_QUERY, "content_s:\"elevator music\""); + 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 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"); + "{!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); - final boolean writeToDocList = false; - Object[] params = + params = new Object[] { CommonParams.SORT, - MonitorFields.QUERY_ID + " desc", + id + " desc", CommonParams.JSON, - read("/monitor/multi-doc-batch.json"), + read("/monitor/doc2.json"), CommonParams.QT, - "/reverseSearch", - WRITE_TO_DOC_LIST_KEY, - writeToDocList + "/reverseSearch" }; - QueryResponse response = query(params); - System.out.println("Response = " + response); - validate(response, 0, List.of("1", "4"), writeToDocList); - validate(response, 1, List.of("7"), writeToDocList); - validate(response, 2, List.of("5"), writeToDocList); - assertEquals(0, ((SolrDocumentList) response.getResponse().get("response")).size()); + response = query(params); + validateDocList(response, List.of("6")); } @Test @@ -163,23 +138,19 @@ public void testDefaultParser() throws Exception { handle.put("responseHeader", SKIP); handle.put("response", SKIP); - final boolean writeToDocList = supportsWriteToDocList(); Object[] params = new Object[] { CommonParams.SORT, id + " desc", CommonParams.JSON, - read("/monitor/multi-doc-batch.json"), + read("/monitor/multi-value-doc.json"), CommonParams.QT, - "/reverseSearch", - WRITE_TO_DOC_LIST_KEY, - writeToDocList + "/reverseSearch" }; QueryResponse response = query(params); System.out.println("Response = " + response); - validate(response, 0, List.of("0"), writeToDocList); - validate(response, 1, List.of("1"), writeToDocList); + validateDocList(response, List.of("1", "0")); } @Test @@ -200,7 +171,6 @@ public void testDisjunctionQuery() throws Exception { handle.put("responseHeader", SKIP); handle.put("response", SKIP); - final boolean writeToDocList = supportsWriteToDocList(); Object[] params = new Object[] { CommonParams.SORT, @@ -208,17 +178,12 @@ public void testDisjunctionQuery() throws Exception { CommonParams.JSON, read("/monitor/single-doc-batch.json"), CommonParams.QT, - "/reverseSearch", - WRITE_TO_DOC_LIST_KEY, - writeToDocList + "/reverseSearch" }; QueryResponse response = query(params); System.out.println("Response = " + response); - if (writeToDocList) { - assertEquals(3, ((SolrDocumentList) response.getResponse().get("response")).size()); - } - validate(response, 0, List.of("0"), writeToDocList); + validateDocList(response, List.of("0")); } @Test @@ -233,7 +198,6 @@ public void testNoDanglingDecomposition() throws Exception { handle.put("responseHeader", SKIP); handle.put("response", SKIP); - final boolean writeToDocList = supportsWriteToDocList(); Object[] params = new Object[] { CommonParams.SORT, @@ -241,17 +205,12 @@ public void testNoDanglingDecomposition() throws Exception { CommonParams.JSON, read("/monitor/dangling-test-single-doc-batch.json"), CommonParams.QT, - "/reverseSearch", - WRITE_TO_DOC_LIST_KEY, - writeToDocList + "/reverseSearch" }; QueryResponse response = query(params); System.out.println("Response = " + response); - if (writeToDocList) { - assertEquals(1, ((SolrDocumentList) response.getResponse().get("response")).size()); - } - validate(response, 0, List.of("0"), writeToDocList); + validateDocList(response, List.of("0")); index( id, @@ -261,10 +220,7 @@ public void testNoDanglingDecomposition() throws Exception { commit(); response = query(params); System.out.println("Response = " + response); - if (writeToDocList) { - assertEquals(0, ((SolrDocumentList) response.getResponse().get("response")).size()); - } - validate(response, 0, List.of(), writeToDocList); + validateDocList(response, List.of()); } @Test @@ -280,7 +236,6 @@ public void testNotQuery() throws Exception { handle.put("responseHeader", SKIP); handle.put("response", SKIP); - final boolean writeToDocList = supportsWriteToDocList(); Object[] params = new Object[] { CommonParams.SORT, @@ -288,14 +243,12 @@ public void testNotQuery() throws Exception { CommonParams.JSON, read("/monitor/single-doc-batch.json"), CommonParams.QT, - "/reverseSearch", - WRITE_TO_DOC_LIST_KEY, - writeToDocList + "/reverseSearch" }; QueryResponse response = query(params); System.out.println("Response = " + response); - validate(response, 0, List.of("1"), writeToDocList); + validateDocList(response, List.of("1")); } @Test @@ -310,26 +263,19 @@ public void testWildCardQuery() throws Exception { handle.put("responseHeader", SKIP); handle.put("response", SKIP); - final boolean writeToDocList = supportsWriteToDocList(); Object[] params = new Object[] { CommonParams.SORT, id + " desc", CommonParams.JSON, - read("/monitor/multi-doc-batch.json"), + read("/monitor/multi-value-doc.json"), CommonParams.QT, - "/reverseSearch", - WRITE_TO_DOC_LIST_KEY, - writeToDocList + "/reverseSearch" }; QueryResponse response = query(params); - if (writeToDocList) { - assertEquals(3, ((SolrDocumentList) response.getResponse().get("response")).size()); - } System.out.println("Response = " + response); - validate(response, 3, List.of("0", "1", "2"), writeToDocList); - validate(response, 4, List.of("0", "1", "2"), writeToDocList); + validateDocList(response, List.of("2", "1", "0")); } @Test @@ -344,7 +290,6 @@ public void testDeleteByQueryId() throws Exception { handle.put("responseHeader", SKIP); handle.put("response", SKIP); - final boolean writeToDocList = supportsWriteToDocList(); Object[] params = new Object[] { CommonParams.SORT, @@ -352,74 +297,34 @@ public void testDeleteByQueryId() throws Exception { CommonParams.JSON, read("/monitor/dangling-test-single-doc-batch.json"), CommonParams.QT, - "/reverseSearch", - WRITE_TO_DOC_LIST_KEY, - writeToDocList + "/reverseSearch" }; QueryResponse response = query(params); - if (writeToDocList) { - assertEquals(1, ((SolrDocumentList) response.getResponse().get("response")).size()); - } - validate(response, 0, List.of("0"), writeToDocList); + validateDocList(response, List.of("0")); del(MonitorFields.QUERY_ID + ":0"); commit(); response = query(CommonParams.Q, "*:*"); - assertEquals(0, ((SolrDocumentList) response.getResponse().get("response")).size()); + validateDocList(response, List.of()); } - void validate(QueryResponse response, int doc, Object expectedValue, boolean writeToDocList) { - var monitorQueries = monitorQueries(response, doc); - assertEquals(expectedValue, monitorQueries); - if (writeToDocList) { - validateDocList(response, doc, expectedValue); - } - } - - void validate( - QueryResponse response, int doc, int query, Object expectedValue, boolean writeToDocList) { - var monitorQueries = monitorQueries(response, doc); - assertTrue(monitorQueries.size() > query); - assertEquals(expectedValue, monitorQueries.get(query)); - if (writeToDocList) { - validateDocList(response, doc, expectedValue); - } - } - - void validateDocList(QueryResponse response, int doc, Object expectedValue) { + 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; - if (expectedValues.size() == 1 && actualValues.size() <= 2) { - assertEquals( - expectedValues.get(0), - actualValues.get(actualValues.size() - 1 - doc).getFieldValue(MonitorFields.QUERY_ID)); + int i = 0; + assertEquals(expectedValues.size(), actualValues.size()); + for (var ev : expectedValues) { + assertEquals(ev, actualValues.get(i).getFieldValue(MonitorFields.QUERY_ID)); + i++; } } } - List monitorQueries(QueryResponse response, int doc) { - assertTrue(response.getResponse().get(MONITOR_OUTPUT_KEY) instanceof Map); - assertTrue( - ((Map) response.getResponse().get(MONITOR_OUTPUT_KEY)).get(MONITOR_DOCUMENTS_KEY) - instanceof Map); - Map monitorDocuments = - (Map) - ((Map) response.getResponse().get(MONITOR_OUTPUT_KEY)).get(MONITOR_DOCUMENTS_KEY); - assertTrue(monitorDocuments.get(doc) instanceof Map); - var nthDoc = (Map) monitorDocuments.get(doc); - assertTrue(nthDoc.get(MONITOR_QUERIES_KEY) instanceof List); - return (List) nthDoc.get(MONITOR_QUERIES_KEY); - } - protected String read(String resourceName) throws IOException, URISyntaxException { final URL url = getClass().getResource(resourceName); return Files.readString(Path.of(url.toURI()), StandardCharsets.UTF_8); } - - protected boolean supportsWriteToDocList() { - return true; - } } diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java index 337e9eb6bf52..e2fab831a00e 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java @@ -19,8 +19,6 @@ package org.apache.solr.monitor; -import static org.apache.solr.monitor.MonitorConstants.WRITE_TO_DOC_LIST_KEY; - import java.net.URL; import java.nio.charset.StandardCharsets; import java.nio.file.Files; @@ -59,19 +57,12 @@ public void coexistWithRegularDocumentsTest() throws Exception { addDoc(commit(), regularChain); addDoc(adoc("id", "1", MonitorFields.MONITOR_QUERY, "content_s:test"), monitorChain); addDoc(commit(), monitorChain); - URL url = getClass().getResource("/monitor/multi-doc-batch.json"); + 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", - WRITE_TO_DOC_LIST_KEY, - "true" + CommonParams.SORT, "id desc", CommonParams.JSON, json, CommonParams.QT, "/reverseSearch" }; assertQ(req(params), "//*[@numFound='1']"); @@ -82,19 +73,12 @@ 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-doc-batch.json"); + 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", - WRITE_TO_DOC_LIST_KEY, - "true" + CommonParams.SORT, "id desc", CommonParams.JSON, json, CommonParams.QT, "/reverseSearch" }; assertQ(req(params), "//*[@numFound='2']"); @@ -152,19 +136,25 @@ public void multiPassPresearcherTest() throws Exception { adoc("id", "3", MonitorFields.MONITOR_QUERY, "content0_s:\"elevator stairs\""), monitorChain); addDoc(commit(), monitorChain); - URL url = getClass().getResource("/monitor/single-doc-batch.json"); + 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.SORT, + "id desc", + CommonParams.JSON, + json, + CommonParams.QT, + "/reverseSearch", + CommonParams.DEBUG_QUERY, + "true" }; assertQ( req(params), - "/response/lst[@name=\"monitor\"]/int[@name=\"queriesRun\"]/text()='1'", - "/response/lst[@name=\"monitor\"]/lst[@name=\"monitorDocuments\"]/lst[@name=\"0\"]/int[@name=\"monitorDocument\"]/text()='0'", - "/response/lst[@name=\"monitor\"]/lst[@name=\"monitorDocuments\"]/lst[@name=\"0\"]/arr[@name=\"queries\"]/str/text()='3'"); + "//*[@numFound='1']", + "/response/lst[@name=\"debug\"]/lst[@name=\"reverse-search-debug\"]/int[@name=\"queriesRun\"]/text()='1'"); } @Test @@ -186,21 +176,27 @@ public void manySegmentsQuery() throws Exception { } }); addDoc(commit(), monitorChain); - URL url = getClass().getResource("/monitor/multi-doc-batch.json"); + 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.SORT, + "id desc", + CommonParams.JSON, + json, + CommonParams.QT, + "/reverseSearch", + CommonParams.DEBUG_QUERY, + "true" }; assertQ( req(params), - "/response/lst[@name=\"monitor\"]/int[@name=\"queriesRun\"]/text()='" + count + "'", - "/response/lst[@name=\"monitor\"]/lst[@name=\"monitorDocuments\"]/lst[@name=\"0\"]/int[@name=\"monitorDocument\"]/text()='0'", - "/response/lst[@name=\"monitor\"]/lst[@name=\"monitorDocuments\"]/lst[@name=\"0\"]/arr[@name=\"queries\"]/str/text()='0'", - "count(/response/lst[@name=\"monitor\"]/lst[@name=\"monitorDocuments\"]/lst[@name=\"0\"]/arr[@name=\"queries\"]/str)=" - + count); + "//*[@numFound='" + count + "']", + "/response/lst[@name=\"debug\"]/lst[@name=\"reverse-search-debug\"]/int[@name=\"queriesRun\"]/text()='" + + count + + "'"); IntStream.range(count / 2, count) .forEach( @@ -220,10 +216,9 @@ public void manySegmentsQuery() throws Exception { addDoc(commit(), monitorChain); assertQ( req(params), - "/response/lst[@name=\"monitor\"]/int[@name=\"queriesRun\"]/text()='" + (count / 2) + "'", - "/response/lst[@name=\"monitor\"]/lst[@name=\"monitorDocuments\"]/lst[@name=\"0\"]/int[@name=\"monitorDocument\"]/text()='0'", - "/response/lst[@name=\"monitor\"]/lst[@name=\"monitorDocuments\"]/lst[@name=\"0\"]/arr[@name=\"queries\"]/str/text()='0'", - "count(/response/lst[@name=\"monitor\"]/lst[@name=\"monitorDocuments\"]/lst[@name=\"0\"]/arr[@name=\"queries\"]/str)=" - + (count / 2)); + "//*[@numFound='" + count / 2 + "']", + "/response/lst[@name=\"debug\"]/lst[@name=\"reverse-search-debug\"]/int[@name=\"queriesRun\"]/text()='" + + count / 2 + + "'"); } } From a24d66a909ad1f4c0a487964d598f85b40f64a37 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Tue, 12 Nov 2024 10:40:47 -0500 Subject: [PATCH 50/85] fix tests --- .../apache/solr/monitor/search/ReverseSearchComponent.java | 1 - .../test/org/apache/solr/monitor/MonitorSolrQueryTest.java | 4 ++-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 7bc3db1db7fe..12b44e85f50a 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -112,7 +112,6 @@ private DocumentBatchVisitor documentBatch(SolrQueryRequest req) { throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "need documents list"); } List luceneDocs = new ArrayList<>(); - int i = 0; for (var document : (List) documents) { if (!(document instanceof Map) || !((Map) document).keySet().stream().allMatch(key -> key instanceof String)) { diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java index ad3167290848..92ed3d1bff61 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java @@ -176,7 +176,7 @@ public void testDisjunctionQuery() throws Exception { CommonParams.SORT, id + " desc", CommonParams.JSON, - read("/monitor/single-doc-batch.json"), + read("/monitor/elevator-doc.json"), CommonParams.QT, "/reverseSearch" }; @@ -241,7 +241,7 @@ public void testNotQuery() throws Exception { CommonParams.SORT, id + " desc", CommonParams.JSON, - read("/monitor/single-doc-batch.json"), + read("/monitor/elevator-doc.json"), CommonParams.QT, "/reverseSearch" }; From 44eea79ba27041555ee5070ad4b6c3e0f6c3bb2a Mon Sep 17 00:00:00 2001 From: Christine Poerschke Date: Wed, 13 Nov 2024 12:03:42 +0000 Subject: [PATCH 51/85] avoid (minimise) solr/core changes --- .../handler/component/DebugComponent.java | 29 ++++----- .../reverse/ReverseSearchDebugInfo.java | 44 ------------- .../search/ReverseSearchDebugComponent.java | 61 +++++++++++++++++++ .../monitor/search/ReverseSearchHandler.java | 2 - .../search/SolrMatcherSinkFactory.java | 6 +- .../collection1/solrconfig-single-core.xml | 12 +++- 6 files changed, 88 insertions(+), 66 deletions(-) delete mode 100644 solr/core/src/java/org/apache/solr/search/reverse/ReverseSearchDebugInfo.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchDebugComponent.java 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 0d3091e08e60..d15274940844 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 @@ -40,7 +40,6 @@ import org.apache.solr.search.QueryParsing; import org.apache.solr.search.SolrIndexSearcher; import org.apache.solr.search.facet.FacetDebugInfo; -import org.apache.solr.search.reverse.ReverseSearchDebugInfo; import org.apache.solr.search.stats.StatsCache; import org.apache.solr.util.SolrPluginUtils; import org.apache.solr.util.SolrResponseUtil; @@ -106,21 +105,7 @@ public void process(ResponseBuilder rb) throws IOException { info.addAll(stdinfo); } - FacetDebugInfo fdebug = (FacetDebugInfo) (rb.req.getContext().get("FacetDebugInfo")); - if (fdebug != null) { - info.add("facet-trace", fdebug.getFacetDebugInfo()); - } - - fdebug = (FacetDebugInfo) (rb.req.getContext().get("FacetDebugInfo-nonJson")); - if (fdebug != null) { - info.add("facet-debug", fdebug.getFacetDebugInfo()); - } - - ReverseSearchDebugInfo rsdebug = - (ReverseSearchDebugInfo) (rb.req.getContext().get(ReverseSearchDebugInfo.KEY)); - if (rsdebug != null) { - info.add("reverse-search-debug", rsdebug.getReverseSearchDebugInfo()); - } + addCustomInfo(rb, info); if (rb.req.getJSON() != null) { info.add(JSON, rb.req.getJSON()); @@ -146,6 +131,18 @@ public void process(ResponseBuilder rb) throws IOException { } } + protected void addCustomInfo(ResponseBuilder rb, NamedList info) { + FacetDebugInfo fdebug = (FacetDebugInfo) (rb.req.getContext().get("FacetDebugInfo")); + if (fdebug != null) { + info.add("facet-trace", fdebug.getFacetDebugInfo()); + } + + fdebug = (FacetDebugInfo) (rb.req.getContext().get("FacetDebugInfo-nonJson")); + if (fdebug != null) { + info.add("facet-debug", fdebug.getFacetDebugInfo()); + } + } + 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/core/src/java/org/apache/solr/search/reverse/ReverseSearchDebugInfo.java b/solr/core/src/java/org/apache/solr/search/reverse/ReverseSearchDebugInfo.java deleted file mode 100644 index 87cbaf58e2e3..000000000000 --- a/solr/core/src/java/org/apache/solr/search/reverse/ReverseSearchDebugInfo.java +++ /dev/null @@ -1,44 +0,0 @@ -/* - * - * * 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.search.reverse; - -import org.apache.solr.common.util.SimpleOrderedMap; - -public class ReverseSearchDebugInfo { - - public static final String KEY = ReverseSearchDebugInfo.class.getSimpleName(); - - private final int queriesRun; - - public ReverseSearchDebugInfo(int queriesRun) { - this.queriesRun = queriesRun; - } - - public int getQueriesRun() { - return queriesRun; - } - - public SimpleOrderedMap getReverseSearchDebugInfo() { - SimpleOrderedMap info = new SimpleOrderedMap<>(); - - info.add("queriesRun", queriesRun); - return info; - } -} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchDebugComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchDebugComponent.java new file mode 100644 index 000000000000..1405f5f725a9 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchDebugComponent.java @@ -0,0 +1,61 @@ +/* + * + * * 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.monitor.search; + +import org.apache.solr.common.util.NamedList; +import org.apache.solr.common.util.SimpleOrderedMap; +import org.apache.solr.handler.component.DebugComponent; +import org.apache.solr.handler.component.ResponseBuilder; + +public class ReverseSearchDebugComponent extends DebugComponent { + public static final String COMPONENT_NAME = "reverseDebug"; + + @Override + protected void addCustomInfo(ResponseBuilder rb, NamedList info) { + super.addCustomInfo(rb, info); + ReverseSearchDebugInfo rsdebug = + (ReverseSearchDebugInfo) (rb.req.getContext().get(ReverseSearchDebugInfo.KEY)); + if (rsdebug != null) { + info.add("reverse-search-debug", rsdebug.getReverseSearchDebugInfo()); + } + } + + public static class ReverseSearchDebugInfo { + + public static final String KEY = ReverseSearchDebugInfo.class.getSimpleName(); + + private final int queriesRun; + + public ReverseSearchDebugInfo(int queriesRun) { + this.queriesRun = queriesRun; + } + + public int getQueriesRun() { + return queriesRun; + } + + public SimpleOrderedMap getReverseSearchDebugInfo() { + SimpleOrderedMap info = new SimpleOrderedMap<>(); + + info.add("queriesRun", queriesRun); + return info; + } + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java index f6d66471c8c5..64e8827fb4c0 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java @@ -21,7 +21,6 @@ import java.util.ArrayList; import java.util.List; -import org.apache.solr.handler.component.DebugComponent; import org.apache.solr.handler.component.QueryComponent; import org.apache.solr.handler.component.SearchHandler; @@ -32,7 +31,6 @@ protected List getDefaultComponents() { ArrayList names = new ArrayList<>(2); names.add(QueryComponent.COMPONENT_NAME); names.add(ReverseSearchComponent.COMPONENT_NAME); - names.add(DebugComponent.COMPONENT_NAME); return names; } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java index 21b0df05f665..a1db58f2a9f9 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java @@ -27,7 +27,6 @@ import org.apache.lucene.monitor.MultiMatchingQueries; import org.apache.lucene.monitor.QueryMatch; import org.apache.lucene.search.IndexSearcher; -import org.apache.solr.search.reverse.ReverseSearchDebugInfo; class SolrMatcherSinkFactory { @@ -38,8 +37,9 @@ SolrMatcherSink build(DocumentBatchVisitor documentBatch, Map re documentBatch, matchingQueries -> reqContext.put( - ReverseSearchDebugInfo.KEY, - new ReverseSearchDebugInfo(matchingQueries.getQueriesRun()))); + ReverseSearchDebugComponent.ReverseSearchDebugInfo.KEY, + new ReverseSearchDebugComponent.ReverseSearchDebugInfo( + matchingQueries.getQueriesRun()))); } private SolrMatcherSink buildSimple( diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-single-core.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-single-core.xml index 78b2930273d1..4b83fd6662f3 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-single-core.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-single-core.xml @@ -86,7 +86,13 @@ - + + + query + reverseSearch + reverseDebug + + explicit @@ -129,6 +135,10 @@ 4 + + + From bf0daf77ec278a20f274a7a0a847b1765a4c1cd9 Mon Sep 17 00:00:00 2001 From: Christine Poerschke Date: Wed, 13 Nov 2024 12:53:10 +0000 Subject: [PATCH 52/85] tentative: no need to configure the query component --- .../apache/solr/monitor/search/ReverseSearchComponent.java | 4 +++- .../org/apache/solr/monitor/search/ReverseSearchHandler.java | 4 +--- .../test-files/solr/collection1/solrconfig-single-core.xml | 1 - 3 files changed, 4 insertions(+), 5 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 12b44e85f50a..a589ab7696e1 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -22,6 +22,7 @@ import static org.apache.solr.monitor.MonitorConstants.MONITOR_DOCUMENTS_KEY; import static org.apache.solr.monitor.search.PresearcherFactory.DEFAULT_ALIAS_PREFIX; +import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.Comparator; @@ -80,7 +81,8 @@ public void init(NamedList args) { } @Override - public void prepare(ResponseBuilder rb) { + public void prepare(ResponseBuilder rb) throws IOException { + super.prepare(rb); var req = rb.req; var documentBatch = documentBatch(req); var matcherSink = solrMatcherSinkFactory.build(documentBatch, rb.req.getContext()); diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java index 64e8827fb4c0..35a89cc5658a 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java @@ -21,15 +21,13 @@ import java.util.ArrayList; import java.util.List; -import org.apache.solr.handler.component.QueryComponent; import org.apache.solr.handler.component.SearchHandler; public class ReverseSearchHandler extends SearchHandler { @Override protected List getDefaultComponents() { - ArrayList names = new ArrayList<>(2); - names.add(QueryComponent.COMPONENT_NAME); + ArrayList names = new ArrayList<>(1); names.add(ReverseSearchComponent.COMPONENT_NAME); return names; } diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-single-core.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-single-core.xml index 4b83fd6662f3..044156c8f79d 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-single-core.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-single-core.xml @@ -88,7 +88,6 @@ - query reverseSearch reverseDebug From 3e7a53c8095f4a33c5ce194abbfb27d154a70571 Mon Sep 17 00:00:00 2001 From: Christine Poerschke Date: Wed, 13 Nov 2024 13:33:32 +0000 Subject: [PATCH 53/85] subjective: remove SolrMatcherSinkFactory now that there's only one Sink type --- .../search/ReverseSearchComponent.java | 18 +++++- .../search/SolrMatcherSinkFactory.java | 57 ------------------- 2 files changed, 16 insertions(+), 59 deletions(-) delete mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index a589ab7696e1..d695ecce750a 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -36,7 +36,9 @@ import org.apache.lucene.monitor.MonitorFields; 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.search.IndexSearcher; import org.apache.lucene.search.MatchAllDocsQuery; import org.apache.lucene.search.Query; import org.apache.lucene.util.BytesRef; @@ -66,7 +68,6 @@ public class ReverseSearchComponent extends QueryComponent implements SolrCoreAw private QueryDecomposer queryDecomposer; private Presearcher presearcher; - private final SolrMatcherSinkFactory solrMatcherSinkFactory = new SolrMatcherSinkFactory(); private PresearcherFactory.PresearcherParameters presearcherParameters; @Override @@ -85,7 +86,20 @@ public void prepare(ResponseBuilder rb) throws IOException { super.prepare(rb); var req = rb.req; var documentBatch = documentBatch(req); - var matcherSink = solrMatcherSinkFactory.build(documentBatch, rb.req.getContext()); + var matcherSink = + new SyncSolrMatcherSink<>( + QueryMatch.SIMPLE_MATCHER::createMatcher, + new IndexSearcher(documentBatch.get()), + matchingQueries -> { + if (rb.isDebug()) { + rb.req + .getContext() + .put( + ReverseSearchDebugComponent.ReverseSearchDebugInfo.KEY, + new ReverseSearchDebugComponent.ReverseSearchDebugInfo( + matchingQueries.getQueriesRun())); + } + }); Query preFilterQuery = presearcher.buildQuery(documentBatch.get(), getTermAcceptor(rb.req)); List mutableFilters = Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java deleted file mode 100644 index a1db58f2a9f9..000000000000 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSinkFactory.java +++ /dev/null @@ -1,57 +0,0 @@ -/* - * - * * 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.monitor.search; - -import java.util.Map; -import java.util.function.Consumer; -import java.util.function.Function; -import org.apache.lucene.monitor.CandidateMatcher; -import org.apache.lucene.monitor.DocumentBatchVisitor; -import org.apache.lucene.monitor.MultiMatchingQueries; -import org.apache.lucene.monitor.QueryMatch; -import org.apache.lucene.search.IndexSearcher; - -class SolrMatcherSinkFactory { - - SolrMatcherSinkFactory() {} - - SolrMatcherSink build(DocumentBatchVisitor documentBatch, Map reqContext) { - return buildSimple( - documentBatch, - matchingQueries -> - reqContext.put( - ReverseSearchDebugComponent.ReverseSearchDebugInfo.KEY, - new ReverseSearchDebugComponent.ReverseSearchDebugInfo( - matchingQueries.getQueriesRun()))); - } - - private SolrMatcherSink buildSimple( - DocumentBatchVisitor documentBatch, Consumer> encoder) { - return build(documentBatch, QueryMatch.SIMPLE_MATCHER::createMatcher, encoder); - } - - private SolrMatcherSink build( - DocumentBatchVisitor documentBatch, - Function> matcherFactory, - Consumer> encoder) { - var docBatchSearcher = new IndexSearcher(documentBatch.get()); - return new SyncSolrMatcherSink<>(matcherFactory, docBatchSearcher, encoder); - } -} From 113ca8fcf90248ee48a80e2245fa5ce839d0c705 Mon Sep 17 00:00:00 2001 From: Christine Poerschke Date: Wed, 13 Nov 2024 18:20:30 +0000 Subject: [PATCH 54/85] some ReverseSearchComponent.prepare reordering and edits to aid code reading comprehension (also removes duplicate req.getSearcher().getCache() call) --- .../search/ReverseSearchComponent.java | 73 +++++++++++-------- 1 file changed, 42 insertions(+), 31 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index d695ecce750a..01f830ae60be 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -32,6 +32,7 @@ import java.util.UUID; import java.util.function.BiPredicate; import org.apache.lucene.document.Document; +import org.apache.lucene.index.LeafReader; import org.apache.lucene.monitor.DocumentBatchVisitor; import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.monitor.Presearcher; @@ -52,7 +53,7 @@ import org.apache.solr.monitor.SolrMonitorQueryDecoder; import org.apache.solr.monitor.cache.MonitorQueryCache; import org.apache.solr.monitor.cache.SharedMonitorCache; -import org.apache.solr.request.SolrQueryRequest; +import org.apache.solr.schema.IndexSchema; import org.apache.solr.schema.SchemaField; import org.apache.solr.update.DocumentBuilder; import org.apache.solr.util.SolrPluginUtils; @@ -84,12 +85,23 @@ public void init(NamedList args) { @Override public void prepare(ResponseBuilder rb) throws IOException { super.prepare(rb); - var req = rb.req; - var documentBatch = documentBatch(req); - var matcherSink = + + rb.setQuery(new MatchAllDocsQuery()); + + final DocumentBatchVisitor documentBatchVisitor = + documentBatchVisitor(rb.req.getJSON(), rb.req.getSchema()); + final LeafReader documentBatch = documentBatchVisitor.get(); + + final MonitorQueryCache monitorQueryCache = + (SharedMonitorCache) rb.req.getSearcher().getCache(this.solrMonitorCacheName); + + final SolrMonitorQueryDecoder solrMonitorQueryDecoder = + new SolrMonitorQueryDecoder(rb.req.getCore()); + + final SolrMatcherSink solrMatcherSink = new SyncSolrMatcherSink<>( QueryMatch.SIMPLE_MATCHER::createMatcher, - new IndexSearcher(documentBatch.get()), + new IndexSearcher(documentBatch), matchingQueries -> { if (rb.isDebug()) { rb.req @@ -100,25 +112,34 @@ public void prepare(ResponseBuilder rb) throws IOException { matchingQueries.getQueriesRun())); } }); - Query preFilterQuery = presearcher.buildQuery(documentBatch.get(), getTermAcceptor(rb.req)); - List mutableFilters = + + final SolrMonitorQueryCollector.CollectorContext collectorContext = + new SolrMonitorQueryCollector.CollectorContext( + monitorQueryCache, solrMonitorQueryDecoder, solrMatcherSink); + + final MonitorPostFilter monitorPostFilter = new MonitorPostFilter(collectorContext); + + final BiPredicate termAcceptor; + if (monitorQueryCache == null) { + termAcceptor = (__, ___) -> true; + } else { + termAcceptor = monitorQueryCache::acceptTerm; + } + final Query preFilterQuery = presearcher.buildQuery(documentBatch, termAcceptor); + + final List mutableFilters = Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); - rb.setQuery(new MatchAllDocsQuery()); + mutableFilters.add(preFilterQuery); - var searcher = req.getSearcher(); - MonitorQueryCache solrMonitorCache = - (SharedMonitorCache) searcher.getCache(this.solrMonitorCacheName); - SolrMonitorQueryDecoder queryDecoder = new SolrMonitorQueryDecoder(req.getCore()); - mutableFilters.add( - new MonitorPostFilter( - new SolrMonitorQueryCollector.CollectorContext( - solrMonitorCache, queryDecoder, matcherSink))); + mutableFilters.add(monitorPostFilter); + rb.setFilters(mutableFilters); } @SuppressWarnings({"unchecked"}) - private DocumentBatchVisitor documentBatch(SolrQueryRequest req) { - Object jsonParams = req.getJSON().get("params"); + 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"); } @@ -135,13 +156,12 @@ private DocumentBatchVisitor documentBatch(SolrQueryRequest req) { SolrException.ErrorCode.BAD_REQUEST, "document needs to be a string-keyed map"); } var docAsMap = (Map) document; - docAsMap.putIfAbsent( - req.getSchema().getUniqueKeyField().getName(), UUID.randomUUID().toString()); + docAsMap.putIfAbsent(indexSchema.getUniqueKeyField().getName(), UUID.randomUUID().toString()); var solrInputDoc = JsonLoader.buildDoc((Map) document); - var luceneDoc = DocumentBuilder.toDocument(solrInputDoc, req.getSchema()); + var luceneDoc = DocumentBuilder.toDocument(solrInputDoc, indexSchema); luceneDocs.add(luceneDoc); } - return DocumentBatchVisitor.of(req.getSchema().getIndexAnalyzer(), luceneDocs); + return DocumentBatchVisitor.of(indexSchema.getIndexAnalyzer(), luceneDocs); } @Override @@ -211,13 +231,4 @@ public QueryDecomposer getQueryDecomposer() { public Presearcher getPresearcher() { return presearcher; } - - private BiPredicate getTermAcceptor(SolrQueryRequest req) { - var searcher = req.getSearcher(); - MonitorQueryCache cache = (MonitorQueryCache) searcher.getCache(this.solrMonitorCacheName); - if (cache == null) { - return (__, ___) -> true; - } - return cache::acceptTerm; - } } From 102cdf0934a64fbe9d05fd8e72eadb0727029e90 Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Sun, 17 Nov 2024 21:11:09 -0500 Subject: [PATCH 55/85] remove MatchesAggregator.java --- .../lucene/monitor/MatchesAggregator.java | 60 ------------------- .../search/ReverseSearchComponent.java | 4 +- .../monitor/search/SyncSolrMatcherSink.java | 17 +++--- 3 files changed, 11 insertions(+), 70 deletions(-) delete mode 100644 solr/modules/monitor/src/java/org/apache/lucene/monitor/MatchesAggregator.java diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatchesAggregator.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatchesAggregator.java deleted file mode 100644 index 9adde58d7e0b..000000000000 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MatchesAggregator.java +++ /dev/null @@ -1,60 +0,0 @@ -/* - * - * * 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.util.List; -import java.util.Map; -import org.apache.lucene.search.Query; - -public class MatchesAggregator extends CandidateMatcher { - - private final CandidateMatcher resolvingMatcher; - - private MatchesAggregator( - List> matchers, CandidateMatcher resolvingMatcher) { - super(resolvingMatcher.searcher); - this.resolvingMatcher = resolvingMatcher; - for (var matcher : matchers) { - var matches = matcher.finish(Long.MIN_VALUE, -1); - for (int doc = 0; doc < matches.getBatchSize(); doc++) { - for (T match : matches.getMatches(doc)) { - this.addMatch(match, doc); - } - } - for (Map.Entry error : matches.getErrors().entrySet()) { - this.reportError(error.getKey(), error.getValue()); - } - } - } - - @Override - public void matchQuery(String queryId, Query matchQuery, Map metadata) { - throw new UnsupportedOperationException("only use for aggregating other matchers"); - } - - @Override - public T resolve(T match1, T match2) { - return resolvingMatcher.resolve(match1, match2); - } - - public static MultiMatchingQueries aggregate( - List> matchers, CandidateMatcher resolver, int queryCount) { - return new MatchesAggregator<>(matchers, resolver).finish(Long.MIN_VALUE, queryCount); - } -} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 01f830ae60be..df2078236ce8 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -102,14 +102,14 @@ public void prepare(ResponseBuilder rb) throws IOException { new SyncSolrMatcherSink<>( QueryMatch.SIMPLE_MATCHER::createMatcher, new IndexSearcher(documentBatch), - matchingQueries -> { + matcherSink -> { if (rb.isDebug()) { rb.req .getContext() .put( ReverseSearchDebugComponent.ReverseSearchDebugInfo.KEY, new ReverseSearchDebugComponent.ReverseSearchDebugInfo( - matchingQueries.getQueriesRun())); + matcherSink.getQueriesRun())); } }); diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java index 238cd12fe0f9..a3f3b2310f02 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java @@ -26,8 +26,6 @@ import java.util.function.Consumer; import java.util.function.Function; import org.apache.lucene.monitor.CandidateMatcher; -import org.apache.lucene.monitor.MatchesAggregator; -import org.apache.lucene.monitor.MultiMatchingQueries; import org.apache.lucene.monitor.QueryMatch; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; @@ -36,14 +34,14 @@ class SyncSolrMatcherSink implements SolrMatcherSink { private final Function> matcherFactory; private final IndexSearcher docBatchSearcher; - private final Consumer> queriesConsumer; + private final Consumer> queriesConsumer; private final List> matchers = new ArrayList<>(); - private int queryCount; + private int queriesRun; SyncSolrMatcherSink( Function> matcherFactory, IndexSearcher docBatchSearcher, - Consumer> queriesConsumer) { + Consumer> queriesConsumer) { this.matcherFactory = matcherFactory; this.docBatchSearcher = docBatchSearcher; this.queriesConsumer = queriesConsumer; @@ -52,7 +50,7 @@ class SyncSolrMatcherSink implements SolrMatcherSink { @Override public boolean matchQuery(String queryId, Query matchQuery, Map metadata) throws IOException { - queryCount++; + queriesRun++; var matcher = matcherFactory.apply(docBatchSearcher); matchers.add(matcher); matcher.matchQuery(queryId, matchQuery, metadata); @@ -68,7 +66,10 @@ public boolean matchQuery(String queryId, Query matchQuery, Map @Override public void complete() { - queriesConsumer.accept( - MatchesAggregator.aggregate(matchers, matcherFactory.apply(docBatchSearcher), queryCount)); + queriesConsumer.accept(this); + } + + public int getQueriesRun() { + return queriesRun; } } From 3795013c9b4e95365c737b83f904e414e9c3441b Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Fri, 22 Nov 2024 23:16:26 -0500 Subject: [PATCH 56/85] update build files --- gradle/libs.versions.toml | 1 + solr/modules/monitor/build.gradle | 8 +- versions.lock | 12535 +++++++++++++++------------- 3 files changed, 6694 insertions(+), 5850 deletions(-) diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 5bfb64e36d85..abf77daf0d47 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/solr/modules/monitor/build.gradle b/solr/modules/monitor/build.gradle index 3d1c3642e20e..3b9c7bb14a99 100644 --- a/solr/modules/monitor/build.gradle +++ b/solr/modules/monitor/build.gradle @@ -23,11 +23,11 @@ dependencies { implementation project(":solr:core") implementation project(":solr:solrj") - implementation "org.apache.lucene:lucene-core" - implementation "org.apache.lucene:lucene-monitor" - implementation 'com.github.ben-manes.caffeine:caffeine' + implementation libs.apache.lucene.core + implementation libs.apache.lucene.monitor + implementation libs.benmanes.caffeine testImplementation project(':solr:test-framework') - testImplementation 'junit:junit' + testImplementation libs.junit.junit } diff --git a/versions.lock b/versions.lock index b2bec0363edd..0ad3c05be650 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" : "9fe1a5c8,refs=54", + "com.carrotsearch:hppc:0.10.0" : "cba6a444,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" : "4dff1176,refs=103", + "com.fasterxml.jackson.core:jackson-core:2.18.0" : "6174b081,refs=104", + "com.fasterxml.jackson.core:jackson-databind:2.18.0" : "9a98b6bd,refs=100", + "com.fasterxml.jackson.dataformat:jackson-dataformat-cbor:2.18.0" : "3be32acc,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" : "2b6e71e2,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" : "2b6e71e2,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" : "d05fa141,refs=108", + "com.fasterxml.woodstox:woodstox-core:7.0.0" : "fe67ba9c,refs=86", + "com.github.ben-manes.caffeine:caffeine:3.1.8" : "0bd4da9d,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" : "21e8fe6d,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" : "21e8fe6d,refs=27", + "com.google.auto.value:auto-value-annotations:1.10.4" : "64b385a8,refs=32", + "com.google.auto:auto-common:1.2.2" : "21e8fe6d,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" : "21e8fe6d,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" : "21e8fe6d,refs=27", + "com.google.errorprone:error_prone_annotations:2.31.0" : "d6325cd7,refs=156", + "com.google.errorprone:error_prone_check_api:2.31.0" : "21e8fe6d,refs=27", + "com.google.errorprone:error_prone_core:2.31.0" : "21e8fe6d,refs=27", + "com.google.errorprone:error_prone_type_annotations:2.31.0" : "21e8fe6d,refs=27", + "com.google.guava:failureaccess:1.0.2" : "d6325cd7,refs=156", + "com.google.guava:guava:33.1.0-jre" : "d6325cd7,refs=156", + "com.google.guava:listenablefuture:9999.0-empty-to-avoid-conflict-with-guava" : "d6325cd7,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" : "a3bf4d96,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" : "0530c27d,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" : "2b6e71e2,refs=83", + "com.jayway.jsonpath:json-path:2.9.0" : "2b6e71e2,refs=83", + "com.lmax:disruptor:3.4.4" : "329bacb5,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" : "2b6e71e2,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" : "10138367,refs=91", + "commons-codec:commons-codec:1.17.1" : "9dad2dca,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" : "cf578285,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" : "2d083e51,refs=49", + "io.dropwizard.metrics:metrics-core:4.2.26" : "d045b497,refs=127", + "io.dropwizard.metrics:metrics-graphite:4.2.26" : "b9eea060,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" : "2d083e51,refs=49", + "io.dropwizard.metrics:metrics-jmx:4.2.26" : "b9eea060,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" : "31a7bc5e,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" : "21e8fe6d,refs=27", + "io.github.java-diff-utils:java-diff-utils:4.12" : "21e8fe6d,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" : "cf578285,refs=130", + "io.netty:netty-codec:4.1.114.Final" : "cf578285,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" : "cf578285,refs=130", + "io.netty:netty-handler:4.1.114.Final" : "cf578285,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" : "cf578285,refs=130", + "io.netty:netty-tcnative-boringssl-static:2.0.66.Final" : "cf578285,refs=130", + "io.netty:netty-tcnative-classes:2.0.66.Final" : "cf578285,refs=130", + "io.netty:netty-transport:4.1.114.Final" : "cf578285,refs=130", + "io.netty:netty-transport-classes-epoll:4.1.114.Final" : "cf578285,refs=130", + "io.netty:netty-transport-native-epoll:4.1.114.Final" : "cf578285,refs=130", + "io.netty:netty-transport-native-unix-common:4.1.114.Final" : "cf578285,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" : "2c377a17,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" : "2c377a17,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" : "2b6e71e2,refs=83", + "io.prometheus:prometheus-metrics-model:1.1.0" : "2b6e71e2,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" : "2b6e71e2,refs=83", + "io.swagger.core.v3:swagger-annotations-jakarta:2.2.22" : "adf8e1c0,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" : "b6eb111e,refs=84", + "jakarta.inject:jakarta.inject-api:2.0.1" : "2b6e71e2,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" : "2b6e71e2,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" : "c549b7b1,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" : "e2ba6832,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" : "9fe1a5c8,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" : "3d248c52,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" : "9917a0a4,refs=85", + "org.apache.commons:commons-lang3:3.15.0" : "fc4f5282,refs=87", + "org.apache.commons:commons-math3:3.6.1" : "a55b8520,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" : "d1868851,refs=129", + "org.apache.curator:curator-framework:5.7.1" : "d1868851,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" : "74b255d2,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" : "8199581b,refs=134", + "org.apache.httpcomponents:httpcore:4.4.16" : "8199581b,refs=134", + "org.apache.httpcomponents:httpmime:4.5.14" : "8199581b,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" : "f6b3fa6a,refs=21", + "org.apache.logging.log4j:log4j-api:2.21.0" : "4f65049f,refs=91", + "org.apache.logging.log4j:log4j-core:2.21.0" : "202a989d,refs=89", + "org.apache.logging.log4j:log4j-layout-template-json:2.21.0" : "4bc7278d,refs=20", + "org.apache.logging.log4j:log4j-slf4j2-impl:2.21.0" : "2814e751,refs=85", + "org.apache.logging.log4j:log4j-web:2.21.0" : "4bc7278d,refs=20", + "org.apache.lucene:lucene-analysis-common:9.11.1" : "2c377a17,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" : "3d248c52,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" : "3d248c52,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" : "3d248c52,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" : "2b6e71e2,refs=83", + "org.apache.lucene:lucene-classification:9.11.1" : "2b6e71e2,refs=83", + "org.apache.lucene:lucene-codecs:9.11.1" : "2b6e71e2,refs=83", + "org.apache.lucene:lucene-core:9.11.1" : "2c377a17,refs=125", + "org.apache.lucene:lucene-expressions:9.11.1" : "2b6e71e2,refs=83", + "org.apache.lucene:lucene-grouping:9.11.1" : "2b6e71e2,refs=83", + "org.apache.lucene:lucene-highlighter:9.11.1" : "2b6e71e2,refs=83", + "org.apache.lucene:lucene-join:9.11.1" : "2b6e71e2,refs=83", + "org.apache.lucene:lucene-memory:9.11.1" : "3d248c52,refs=81", + "org.apache.lucene:lucene-misc:9.11.1" : "2b6e71e2,refs=83", + "org.apache.lucene:lucene-monitor:9.11.1" : "286d3ac2,refs=5", + "org.apache.lucene:lucene-queries:9.11.1" : "2c377a17,refs=125", + "org.apache.lucene:lucene-queryparser:9.11.1" : "2b6e71e2,refs=83", + "org.apache.lucene:lucene-sandbox:9.11.1" : "2b6e71e2,refs=83", + "org.apache.lucene:lucene-spatial-extras:9.11.1" : "2b6e71e2,refs=83", + "org.apache.lucene:lucene-spatial3d:9.11.1" : "2b6e71e2,refs=83", + "org.apache.lucene:lucene-suggest:9.11.1" : "02377b26,refs=85", + "org.apache.lucene:lucene-test-framework:9.11.1" : "9fe1a5c8,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" : "cf578285,refs=130", + "org.apache.zookeeper:zookeeper-jute:3.9.2" : "cf578285,refs=130", + "org.apiguardian:apiguardian-api:1.1.2" : "1a0f3663,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" : "d6325cd7,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" : "9917a0a4,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" : "8199581b,refs=134", + "org.eclipse.jetty.http2:http2-common:10.0.22" : "4d22574d,refs=136", + "org.eclipse.jetty.http2:http2-hpack:10.0.22" : "4d22574d,refs=136", + "org.eclipse.jetty.http2:http2-http-client-transport:10.0.22" : "3708202c,refs=88", + "org.eclipse.jetty.http2:http2-server:10.0.22" : "f19e2720,refs=33", + "org.eclipse.jetty.toolchain:jetty-servlet-api:4.0.6" : "74dcd88a,refs=114", + "org.eclipse.jetty:jetty-alpn-client:10.0.22" : "8199581b,refs=134", + "org.eclipse.jetty:jetty-alpn-java-client:10.0.22" : "3708202c,refs=88", + "org.eclipse.jetty:jetty-alpn-java-server:10.0.22" : "1ad7b364,refs=31", + "org.eclipse.jetty:jetty-alpn-server:10.0.22" : "f19e2720,refs=33", + "org.eclipse.jetty:jetty-client:10.0.22" : "7f2093e0,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" : "4d22574d,refs=136", + "org.eclipse.jetty:jetty-io:10.0.22" : "4d22574d,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" : "f19e2720,refs=33", + "org.eclipse.jetty:jetty-security:10.0.22" : "7068fbcc,refs=61", + "org.eclipse.jetty:jetty-server:10.0.22" : "0e0be560,refs=112", + "org.eclipse.jetty:jetty-servlet:10.0.22" : "7068fbcc,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" : "4d22574d,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" : "2b6e71e2,refs=83", + "org.glassfish.hk2:hk2-api:3.1.1" : "2b6e71e2,refs=83", + "org.glassfish.hk2:hk2-locator:3.1.1" : "2b6e71e2,refs=83", + "org.glassfish.hk2:hk2-utils:3.1.1" : "2b6e71e2,refs=83", + "org.glassfish.hk2:osgi-resource-locator:1.0.3" : "2b6e71e2,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" : "2b6e71e2,refs=83", + "org.glassfish.jersey.core:jersey-client:3.1.9" : "2b6e71e2,refs=83", + "org.glassfish.jersey.core:jersey-common:3.1.9" : "2b6e71e2,refs=83", + "org.glassfish.jersey.core:jersey-server:3.1.9" : "2b6e71e2,refs=83", + "org.glassfish.jersey.ext:jersey-entity-filtering:3.1.9" : "2b6e71e2,refs=83", + "org.glassfish.jersey.inject:jersey-hk2:3.1.9" : "2b6e71e2,refs=83", + "org.glassfish.jersey.media:jersey-media-json-jackson:3.1.9" : "2b6e71e2,refs=83", + "org.hamcrest:hamcrest:3.0" : "9fe1a5c8,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" : "2b6e71e2,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" : "21e8fe6d,refs=27", + "org.junit.jupiter:junit-jupiter-api:5.6.2" : "74b255d2,refs=30", + "org.junit.platform:junit-platform-commons:1.6.2" : "74b255d2,refs=30", + "org.junit:junit-bom:5.6.2" : "74b255d2,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" : "2b6e71e2,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" : "74b255d2,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" : "6e47ac53,refs=84", + "org.ow2.asm:asm-analysis:7.2" : "3d248c52,refs=81", + "org.ow2.asm:asm-commons:7.2" : "3d248c52,refs=81", + "org.ow2.asm:asm-tree:7.2" : "3d248c52,refs=81", + "org.pcollections:pcollections:4.0.1" : "4e99a97b,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" : "bd115d81,refs=89", + "org.slf4j:jcl-over-slf4j:2.0.13" : "eaeef440,refs=90", + "org.slf4j:jul-to-slf4j:2.0.13" : "bb22e93c,refs=27", + "org.slf4j:slf4j-api:2.0.13" : "b5a069d5,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" : "b452c0f7,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" - }, + "02377b26" : [ { "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,33 +583,25 @@ "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { "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" @@ -652,7 +623,19 @@ "projectPath" : ":solr:test-framework" }, { - "configuration" : "testCompileClasspath", + "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" }, { @@ -660,7 +643,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 +659,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,7 +675,15 @@ "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, { @@ -684,256 +691,266 @@ "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "solrPlatformLibs", + "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:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "0769b123" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - } - ], - "08ef8dc6" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:monitor" }, { "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: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" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:sql" + } + ], + "0530c27d" : [ + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeLibs", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", @@ -944,7 +961,7 @@ "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:extraction" }, { @@ -952,164 +969,152 @@ "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:gcs-repository" }, { "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" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:sql" + } + ], + "062c26b4" : [ + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "serverLib", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:solrj" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:s3-repository" + } + ], + "0769b123" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:cross-dc-manager" } ], "0a82b27c" : [ @@ -1178,52 +1183,42 @@ "projectPath" : ":solr:modules:opentelemetry" } ], - "0d28f997" : [ + "0bd4da9d" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - } - ], - "0e779887" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:benchmark" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:core" }, { "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", @@ -1234,7 +1229,7 @@ "projectPath" : ":solr:core" }, { - "configuration" : "compileClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:cross-dc-manager" }, { @@ -1250,12 +1245,28 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "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", @@ -1265,16 +1276,20 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:server" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" }, { - "configuration" : "serverLib", + "configuration" : "solrCore", "projectPath" : ":solr:server" }, { - "configuration" : "testCompileClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:solr-ref-guide" }, { @@ -1282,7 +1297,7 @@ "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testCompileClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:solrj" }, { @@ -1290,7 +1305,7 @@ "projectPath" : ":solr:solrj" }, { - "configuration" : "testCompileClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:solrj-streaming" }, { @@ -1298,7 +1313,7 @@ "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "testCompileClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:solrj-zookeeper" }, { @@ -1306,7 +1321,7 @@ "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "compileClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:test-framework" }, { @@ -1314,791 +1329,815 @@ "projectPath" : ":solr:test-framework" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:webapp" }, { - "configuration" : "serverLib", + "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, { - "configuration" : "testCompileClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "100652ac" : [ + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:sql" + } + ], + "0d28f997" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, + "projectPath" : ":solr:modules:opentelemetry" + } + ], + "0e0be560" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "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" - }, - { - "configuration" : "solrPlatformLibs", - "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" + "projectPath" : ":solr:core" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "serverLib", + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeClasspath", - "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" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "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" + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, + { + "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" + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "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" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "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" + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "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" - } - ], - "1069c1cc" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "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" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "1640bbba" : [ + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" - } - ], - "1643ad05" : [ + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "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" } ], - "17e13daa" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" - }, + "10138367" : [ { "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" @@ -2123,10 +2162,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -2140,12 +2175,20 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "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", @@ -2167,34 +2210,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" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" @@ -2219,10 +2246,6 @@ "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -2235,18 +2258,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" @@ -2259,18 +2274,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" @@ -2283,18 +2290,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" @@ -2307,18 +2306,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" @@ -2331,18 +2322,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" @@ -2355,10 +2338,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -2387,10 +2366,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -2403,18 +2378,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" @@ -2427,18 +2394,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" @@ -2452,16 +2411,24 @@ "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "runtimeClasspath", @@ -2475,18 +2442,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" @@ -2499,18 +2458,10 @@ "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:scripting" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -2523,18 +2474,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" @@ -2547,51 +2490,41 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "1b72eeae" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, + "1643ad05" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - }, + "projectPath" : ":solr:modules:hadoop-auth" + } + ], + "1a0f3663" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testCompileClasspath", @@ -2602,201 +2535,1711 @@ "projectPath" : ":solr:core" }, { - "configuration" : "compileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "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" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, + "projectPath" : ":solr:modules:sql" + } + ], + "1ad7b364" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:benchmark" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:core" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "serverLib", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "compileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" - }, + "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:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "1e12e466" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "202a989d" : [ + { + "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" + }, + { + "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" : "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" : "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" + }, + { + "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" : "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" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "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", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "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" + }, + { + "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" : "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:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "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: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" + } + ], + "20f1e0e0" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "21e8fe6d" : [ + { + "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" : "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:monitor" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" + } + ], + "23e8a2eb" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + } + ], + "24396a00" : [ + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:server" + }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + } + ], + "26b9da63" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + } + ], + "280cfec8" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + } + ], + "2814e751" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeLibs", + "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" : "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" : "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" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "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" + }, + { + "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" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "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", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "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" + }, + { + "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" : "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:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "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: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" + } + ], + "286d3ac2" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + } + ], + "2b6e71e2" : [ + { + "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" + }, + { + "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" : "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" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "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", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "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" + }, + { + "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" : "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:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "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: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" + } + ], + "2c377a17" : [ + { + "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" + }, + { + "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" : "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" : "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" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "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" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "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" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -2973,6 +4416,30 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -3070,17 +4537,13 @@ "projectPath" : ":solr:modules:sql" } ], - "1e12e466" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, + "2d06957b" : [ { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" } ], - "1f5bde05" : [ + "2d083e51" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -3237,6 +4700,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, { "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" @@ -3270,45 +4741,15 @@ "projectPath" : ":solr:modules:sql" } ], - "20f1e0e0" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "21136b15" : [ + "31a7bc5e" : [ { "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" @@ -3333,6 +4774,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -3345,6 +4790,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -3357,6 +4806,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "libExt", + "projectPath" : ":solr:server" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -3373,18 +4826,6 @@ "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" @@ -3401,6 +4842,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -3453,10 +4898,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -3469,10 +4910,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -3571,124 +5008,204 @@ }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "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: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" + } + ], + "329bacb5" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "libExt", + "projectPath" : ":solr:server" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "23e8a2eb" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - } - ], - "24396a00" : [ { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:server" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" - } - ], - "26b9da63" : [ + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" } ], - "27f62655" : [ + "3708202c" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -3701,10 +5218,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -3713,10 +5226,6 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:core" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" @@ -3738,16 +5247,20 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", @@ -3761,14 +5274,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" @@ -3781,10 +5314,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" - }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -3922,245 +5451,137 @@ "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" : "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" - } - ], - "280cfec8" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - } - ], - "2d06957b" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" - } - ], - "322f4a3c" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:api" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:server" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:test-framework" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:webapp" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:clustering" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:extraction" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:langid" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "3b210678" : [ { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" } ], - "36393977" : [ + "3be32acc" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -4305,10 +5726,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -4321,10 +5738,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -4373,10 +5786,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -4390,251 +5799,131 @@ "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" : "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" - } - ], - "3b210678" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "3c9a199e" : [ + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "3ff3bc39" : [ + "3d248c52" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -4647,10 +5936,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -4659,10 +5944,6 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:core" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" @@ -4743,10 +6024,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:clustering" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -4759,10 +6036,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -4895,6 +6168,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -4960,15 +6249,109 @@ "projectPath" : ":solr:modules:sql" } ], - "420fd813" : [ + "4985a322" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:api" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + } + ], + "4bc7278d" : [ + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "libExt", + "projectPath" : ":solr:server" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:api" + "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:monitor" + }, + { + "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" + } + ], + "4bf37e93" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + } + ], + "4d22574d" : [ { "configuration" : "testCompileClasspath", "projectPath" : ":solr:api" @@ -5065,6 +6448,10 @@ "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:server" + }, { "configuration" : "solrCore", "projectPath" : ":solr:server" @@ -5141,6 +6528,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -5383,7 +6774,31 @@ }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "compileClasspath", @@ -5482,27 +6897,7 @@ "projectPath" : ":solr:modules:sql" } ], - "4985a322" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - } - ], - "4bf37e93" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - } - ], - "4ce82561" : [ + "4dff1176" : [ { "configuration" : "compileClasspath", "projectPath" : ":solr:api" @@ -5823,6 +7218,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -5900,211 +7311,29 @@ "projectPath" : ":solr:modules:sql" } ], - "4f81d786" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - } - ], - "50a667d1" : [ - { - "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" - } - ], - "515616b6" : [ - { - "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" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - } - ], - "52ada00b" : [ + "4e99a97b" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" }, { - "configuration" : "runtimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:benchmark" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - } - ], - "58171492" : [ - { - "configuration" : "solrPlatformLibs", + "configuration" : "annotationProcessor", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "solrPlatformLibs", - "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" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:cross-dc-manager" }, { "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" : "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" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" - } - ], - "5967e690" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, { @@ -6112,111 +7341,99 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" - }, - { - "configuration" : "serverLib", + "configuration" : "annotationProcessor", "projectPath" : ":solr:server" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:solrj" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "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" : "annotationProcessor", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:test-framework" }, { - "configuration" : "serverLib", + "configuration" : "annotationProcessor", "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:sql" } ], - "5b11e899" : [ + "4f65049f" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -6265,6 +7482,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" @@ -6273,6 +7498,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "libExt", + "projectPath" : ":solr:server" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -6297,14 +7526,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" @@ -6454,313 +7695,123 @@ "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" : "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" - } - ], - "5b2db4f4" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:api" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "runtimeClasspath", - "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" : "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" : "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" : "annotationProcessor", - "projectPath" : ":solr:server" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" - }, - { - "configuration" : "solrCore", - "projectPath" : ":solr:server" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:webapp" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:s3-repository" }, { "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" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "annotationProcessor", - "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:cross-dc" + "projectPath" : ":solr:modules:sql" + } + ], + "4f81d786" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "annotationProcessor", + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + } + ], + "50a667d1" : [ + { + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:extraction" }, { @@ -6772,57 +7823,63 @@ "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" - }, + } + ], + "515616b6" : [ { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:gcs-repository" + "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" : "annotationProcessor", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + } + ], + "52ada00b" : [ { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hdfs" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + } + ], + "5f4312f3" : [ { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:hdfs" @@ -6835,10 +7892,6 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:hdfs" @@ -6846,61 +7899,67 @@ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" + } + ], + "5f62bd8e" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:solrj" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:langid" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:ltr" }, { @@ -6908,9 +7967,21 @@ "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "5fc760f2" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + } + ], + "5fcc0587" : [ { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -6920,129 +7991,137 @@ "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" + } + ], + "6174b081" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:benchmark" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:core" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:core" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" + "configuration" : "compileClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "5d98342f" : [ + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:server" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" }, { @@ -7050,1036 +8129,990 @@ "projectPath" : ":solr:test-framework" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "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" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "5e82f1c0" : [ { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hadoop-auth" }, { "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" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:opentelemetry" }, { "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" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "compileClasspath", + "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: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" + } + ], + "64b385a8" : [ + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:core" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:server" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:webapp" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" + } + ], + "69bf1b73" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:langid" + } + ], + "6e47ac53" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "5f4312f3" : [ + "projectPath" : ":solr:solrj-streaming" + }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - } - ], - "5f62bd8e" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "5fb053e8" : [ + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "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" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" - }, - { - "configuration" : "serverLib", - "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" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { "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:analysis-extras" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:clustering" - }, + "projectPath" : ":solr:modules:sql" + } + ], + "6fb73f3a" : [ { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + } + ], + "7068fbcc" : [ { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:api" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:api" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:benchmark" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:core" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "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:modules:extraction" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "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" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:test-framework" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testCompileClasspath", @@ -8090,20 +9123,12 @@ "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "testCompileClasspath", @@ -8114,207 +9139,203 @@ "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "compileClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, + "projectPath" : ":solr:modules:sql" + } + ], + "727aea63" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "compileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" - }, + } + ], + "74b255d2" : [ { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "5fc760f2" : [ - { - "configuration" : "compileClasspath", "projectPath" : ":solr:core" - } - ], - "5fcc0587" : [ + }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - } - ], - "6351de37" : [ + "projectPath" : ":solr:solr-ref-guide" + }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "69bf1b73" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" - }, + "74dcd88a" : [ { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:api" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" - } - ], - "6a8501ec" : [ { "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" @@ -8363,18 +9384,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" @@ -8392,20 +9401,20 @@ "projectPath" : ":solr:server" }, { - "configuration" : "solrCore", + "configuration" : "serverLib", "projectPath" : ":solr:server" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "testCompileClasspath", @@ -8416,7 +9425,7 @@ "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-streaming" }, { @@ -8424,21 +9433,33 @@ "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeClasspath", + "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" @@ -8455,6 +9476,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -8471,6 +9496,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -8488,12 +9517,12 @@ "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeClasspath", @@ -8515,10 +9544,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -8575,10 +9600,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" @@ -8611,6 +9644,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:langid" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" @@ -8627,10 +9664,34 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -8643,6 +9704,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -8680,12 +9745,12 @@ "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", @@ -8708,151 +9773,119 @@ "projectPath" : ":solr:modules:sql" } ], - "6ac4140f" : [ + "761c3c3c" : [ { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" - }, + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + } + ], + "778d978f" : [ { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "projectPath" : ":solr:benchmark" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" - }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + } + ], + "781655d3" : [ { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" - }, + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + } + ], + "784a94ea" : [ { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "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" : "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:scripting" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" } ], - "6fb73f3a" : [ + "7accccef" : [ { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:s3-repository" } ], - "703dff64" : [ + "7df0e72e" : [ { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "7f2093e0" : [ { "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 +9910,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -8893,10 +9922,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -8913,10 +9938,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" @@ -8930,12 +9951,16 @@ "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", @@ -8946,41 +9971,25 @@ "projectPath" : ":solr:solrj" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", "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" @@ -8989,10 +9998,6 @@ "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -9005,18 +10010,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 +10026,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,18 +10042,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" @@ -9077,18 +10058,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" @@ -9101,10 +10074,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -9133,10 +10102,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -9149,10 +10114,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -9181,10 +10142,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:langid" @@ -9197,18 +10154,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" @@ -9222,16 +10171,24 @@ "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "runtimeClasspath", @@ -9245,18 +10202,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" @@ -9269,18 +10218,10 @@ "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:scripting" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -9293,18 +10234,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,52 +10250,30 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "727aea63" : [ + "8199581b" : [ { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:api" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "72c9c512" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:benchmark" }, { @@ -9389,6 +10300,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -9401,10 +10316,18 @@ "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" @@ -9417,33 +10340,73 @@ "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" : "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:server" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testRuntimeClasspath", @@ -9466,12 +10429,12 @@ "projectPath" : ":solr:test-framework" }, { - "configuration" : "serverLib", + "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeClasspath", @@ -9485,10 +10448,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" @@ -9501,10 +10472,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" @@ -9518,419 +10497,325 @@ "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "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" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" }, { "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" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:gcs-repository" }, { "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" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testCompileClasspath", + "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" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "compileClasspath", + "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" : "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" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { "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" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "7413b098" : [ { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" - }, - { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" - }, + "projectPath" : ":solr:modules:sql" + } + ], + "87cc13ff" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, + "projectPath" : ":solr:modules:s3-repository" + } + ], + "8ba2f0f7" : [ { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:extraction" @@ -9944,413 +10829,411 @@ "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:jwt-auth" + } + ], + "8d0cef4c" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "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" : "compileClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" - }, + } + ], + "934e1fc5" : [ { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeLibs", + "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" + } + ], + "93acde90" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "970f2ee7" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + } + ], + "9917a0a4" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:benchmark" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:core" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "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:modules:langid" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:ltr" + "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:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "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" - } - ], - "7498dc3d" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:api" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:core" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:webapp" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:clustering" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:extraction" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:langid" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "annotationProcessor", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "runtimeClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "runtimeLibs", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" }, { @@ -10358,73 +11241,55 @@ "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "761c3c3c" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" } ], - "76db8e26" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" - }, + "9a98b6bd" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -10457,6 +11322,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -10469,10 +11338,18 @@ "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" @@ -10485,6 +11362,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" @@ -10501,10 +11382,18 @@ "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" @@ -10585,6 +11474,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -10597,6 +11490,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -10661,6 +11558,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -10697,6 +11598,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -10725,6 +11642,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -10746,43 +11667,31 @@ "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "runtimeClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:sql" }, { - "configuration" : "runtimeLibs", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" - } - ], - "778d978f" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - }, + "projectPath" : ":solr:modules:sql" + } + ], + "9bcc8206" : [ { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -10794,45 +11703,45 @@ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" - } - ], - "781655d3" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" - } - ], - "784a94ea" : [ + }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:jwt-auth" } ], - "78dd58c9" : [ + "9dad2dca" : [ { "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" @@ -10873,10 +11782,26 @@ "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" @@ -10893,22 +11818,58 @@ "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" : "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" @@ -10949,6 +11910,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -10961,10 +11926,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" @@ -10977,10 +11950,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" @@ -10993,10 +11974,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" @@ -11009,6 +11998,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -11025,10 +12018,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" @@ -11041,6 +12042,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -11077,6 +12082,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -11093,6 +12114,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -11146,44 +12171,68 @@ "projectPath" : ":solr:modules:sql" } ], - "7accccef" : [ + "9e97e18c" : [ { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "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" } ], - "7bb67147" : [ + "9fe1a5c8" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" }, { - "configuration" : "runtimeClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:benchmark" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testCompileClasspath", @@ -11194,15 +12243,7 @@ "projectPath" : ":solr:core" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:cross-dc-manager" }, { @@ -11210,7 +12251,7 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:prometheus-exporter" }, { @@ -11218,67 +12259,63 @@ "projectPath" : ":solr:prometheus-exporter" }, { - "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" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:clustering" }, { @@ -11286,37 +12323,13 @@ "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" }, { "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", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:extraction" @@ -11326,15 +12339,7 @@ "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" }, { @@ -11342,15 +12347,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" }, { @@ -11358,15 +12355,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" }, { @@ -11374,15 +12363,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" }, { @@ -11390,15 +12371,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" }, { @@ -11406,15 +12379,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" }, { @@ -11422,33 +12387,21 @@ "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "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" @@ -11458,15 +12411,7 @@ "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:scripting" }, { @@ -11474,15 +12419,7 @@ "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:sql" }, { @@ -11490,196 +12427,114 @@ "projectPath" : ":solr:modules:sql" } ], - "7df0e72e" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "7f2dd9d5" : [ + "a3bf4d96" : [ { - "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" : "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" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "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" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "runtimeLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", @@ -11690,7 +12545,7 @@ "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:gcs-repository" }, { @@ -11701,171 +12556,91 @@ "configuration" : "compileClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "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" : "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" : "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" : "compileClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:sql" } ], - "84afbb60" : [ + "a55b8520" : [ { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" }, { "configuration" : "compileClasspath", @@ -11903,10 +12678,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -11919,69 +12690,29 @@ "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" : "runtimeClasspath", - "projectPath" : ":solr:server" - }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:server" - }, - { - "configuration" : "solrCore", - "projectPath" : ":solr:server" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "testRuntimeClasspath", @@ -12003,50 +12734,22 @@ "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" @@ -12059,18 +12762,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" @@ -12083,18 +12778,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" @@ -12107,10 +12794,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -12139,10 +12822,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -12155,18 +12834,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" @@ -12179,18 +12850,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" @@ -12203,18 +12866,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" @@ -12227,18 +12882,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" @@ -12251,18 +12898,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" @@ -12276,16 +12915,24 @@ "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "runtimeClasspath", @@ -12299,18 +12946,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" @@ -12323,18 +12962,10 @@ "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:scripting" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -12348,31 +12979,75 @@ "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "compileClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:sql" }, { - "configuration" : "runtimeClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, { - "configuration" : "runtimeLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" + } + ], + "a5b348ef" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + } + ], + "a6a1e3c5" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:sql" }, { @@ -12380,29 +13055,85 @@ "projectPath" : ":solr:modules:sql" } ], - "87cc13ff" : [ + "a7f96198" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "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" + } + ], + "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" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:hadoop-auth" } ], - "87cd582a" : [ + "adf8e1c0" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:api" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:api" @@ -12471,6 +13202,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" @@ -12483,10 +13226,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, - { - "configuration" : "libExt", - "projectPath" : ":solr:server" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -12503,6 +13242,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj" @@ -12511,6 +13258,14 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-streaming" @@ -12519,6 +13274,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" @@ -12543,10 +13306,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" - }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -12791,6 +13550,30 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -12888,7 +13671,7 @@ "projectPath" : ":solr:modules:sql" } ], - "8b517977" : [ + "b452c0f7" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -12901,10 +13684,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -12957,10 +13736,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" @@ -12973,10 +13748,18 @@ "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" @@ -13081,6 +13864,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -13093,6 +13880,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -13147,862 +13938,700 @@ }, { "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: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" - } - ], - "8ba2f0f7" : [ - { - "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:jwt-auth" - } - ], - "8d0cef4c" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, - { - "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: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" - } - ], - "90aa62e6" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - } - ], - "934e1fc5" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - } - ], - "93acde90" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "970f2ee7" : [ + "projectPath" : ":solr:modules:opentelemetry" + }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" - } - ], - "99b82a6c" : [ + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, + "projectPath" : ":solr:modules:sql" + } + ], + "b4755bf3" : [ { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "b5a069d5" : [ { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:api" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:api" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:api" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:core" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:core" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "libExt", + "projectPath" : ":solr:server" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "serverLib", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrCore", + "projectPath" : ":solr:server" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:solrj" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "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" + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:clustering" }, { "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" + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "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" + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "compileClasspath", + "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" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "9bcc8206" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "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" - } - ], - "9e97e18c" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "a05ffa28" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "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" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "compileClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, { "configuration" : "compileClasspath", "projectPath" : ":solr:modules:sql" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "a5b348ef" : [ { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:sql" } ], - "a6a1e3c5" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, + "b6a343e2" : [ { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:jwt-auth" }, { "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" + "projectPath" : ":solr:modules:opentelemetry" } ], - "a6fb6a35" : [ + "b6eb111e" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -14015,6 +14644,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -14023,6 +14656,10 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:core" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" @@ -14043,14 +14680,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" @@ -14059,10 +14688,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, - { - "configuration" : "libExt", - "projectPath" : ":solr:server" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -14075,26 +14700,14 @@ "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" @@ -14107,10 +14720,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" - }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -14163,10 +14772,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -14179,10 +14784,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -14252,287 +14853,165 @@ "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" : "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" - } - ], - "a7f96198" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testRuntimeClasspath", - "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:gcs-repository" - } - ], - "a9dcee72" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:api" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:core" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:webapp" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:extraction" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "annotationProcessor", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "annotationProcessor", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" - } - ], - "aa7a59c6" : [ + }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:sql" } ], - "acc31ef6" : [ + "b6f115a3" : [ + { + "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" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:langid" } ], - "ad8f08d7" : [ + "b9eea060" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -14589,6 +15068,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "libExt", + "projectPath" : ":solr:server" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -14621,6 +15104,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -14707,165 +15194,299 @@ }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "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" : "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:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "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:hadoop-auth" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:sql" + } + ], + "bb22e93c" : [ + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "libExt", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" } ], - "b3b7541b" : [ + "bd115d81" : [ { - "configuration" : "testRuntimeClasspath", + "configuration" : "compileClasspath", "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" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "runtimeClasspath", @@ -14875,10 +15496,6 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:core" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" @@ -14899,6 +15516,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" @@ -14920,27 +15545,31 @@ "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "runtimeClasspath", "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" }, { @@ -15111,6 +15740,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -15176,45 +15821,47 @@ "projectPath" : ":solr:modules:sql" } ], - "b4755bf3" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, + "bf04d2b8" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, + "projectPath" : ":solr:modules:hadoop-auth" + } + ], + "c1e4e901" : [ { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:opentelemetry" } ], - "b57e9bf6" : [ + "c549b7b1" : [ { "configuration" : "compileClasspath", "projectPath" : ":solr:api" @@ -15239,6 +15886,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -15247,6 +15898,10 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:core" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" @@ -15491,6 +16146,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -15556,71 +16227,81 @@ "projectPath" : ":solr:modules:sql" } ], - "b6a343e2" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, + "c6acb8a9" : [ { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - } - ], - "b6f115a3" : [ + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:cross-dc" + } + ], + "c718e885" : [ + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" }, { "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" } ], - "bc8e8214" : [ + "c77c5ec7" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + } + ], + "cba6a444" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -15669,14 +16350,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 +16358,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, - { - "configuration" : "libExt", - "projectPath" : ":solr:server" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -15713,26 +16382,14 @@ "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" @@ -15753,6 +16410,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -15765,6 +16426,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -15785,10 +16450,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -15801,10 +16462,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -15859,261 +16516,67 @@ }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "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" : "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" - } - ], - "bddbe009" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:api" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:core" - }, - { - "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" - }, - { - "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" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" - } - ], - "bf04d2b8" : [ + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - } - ], - "c1e4e901" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "runtimeClasspath", @@ -16124,82 +16587,60 @@ "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:opentelemetry" - } - ], - "c6acb8a9" : [ + }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "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" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - } - ], - "c718e885" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - } - ], - "c77c5ec7" : [ + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:sql" } ], "cef2dbfe" : [ @@ -16236,7 +16677,7 @@ "projectPath" : ":solr:modules:opentelemetry" } ], - "d008b72a" : [ + "cf578285" : [ { "configuration" : "testCompileClasspath", "projectPath" : ":solr:api" @@ -16305,6 +16746,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" @@ -16321,10 +16774,6 @@ "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:server" - }, { "configuration" : "solrCore", "projectPath" : ":solr:server" @@ -16353,6 +16802,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" @@ -16378,12 +16835,12 @@ "projectPath" : ":solr:test-framework" }, { - "configuration" : "serverLib", + "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeClasspath", @@ -16405,6 +16862,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -16425,6 +16886,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -16445,6 +16910,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -16465,6 +16934,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -16485,6 +16958,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -16505,6 +16982,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -16525,6 +17006,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -16545,6 +17030,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:langid" @@ -16565,6 +17054,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:ltr" @@ -16585,6 +17078,34 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -16605,6 +17126,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -16625,6 +17150,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -16645,6 +17174,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -16666,21 +17199,27 @@ "projectPath" : ":solr:modules:sql" } ], - "d3d191b2" : [ + "d045b497" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "dc28f153" : [ + "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" @@ -16733,6 +17272,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" @@ -16749,26 +17292,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" + "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" @@ -16781,6 +17348,10 @@ "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -16793,10 +17364,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" @@ -16809,10 +17388,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" @@ -16825,10 +17412,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" @@ -16841,10 +17436,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" @@ -16857,10 +17460,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" @@ -16873,10 +17484,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" @@ -16889,10 +17508,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" @@ -16905,10 +17532,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" @@ -16921,10 +17556,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" @@ -16937,10 +17580,42 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -16953,10 +17628,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" @@ -16969,10 +17652,18 @@ "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:scripting" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -16985,10 +17676,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" @@ -17001,38 +17700,28 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "dd724fae" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" - }, + "d05fa141" : [ { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "compileClasspath", + "projectPath" : ":solr:api" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:api" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - } - ], - "ddc123c8" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -17045,6 +17734,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -17053,10 +17746,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" @@ -17069,14 +17770,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" @@ -17093,14 +17814,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" @@ -17189,6 +17930,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -17201,10 +17946,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" @@ -17217,6 +17970,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -17237,6 +17994,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -17289,6 +18050,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -17317,6 +18094,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -17337,6 +18118,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -17349,48 +18134,34 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "debe9836" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" - }, + "d1868851" : [ { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:api" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:api" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "e19ba4dc" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:benchmark" }, { @@ -17417,6 +18188,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -17430,12 +18205,12 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", @@ -17465,18 +18240,42 @@ "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" @@ -17501,6 +18300,10 @@ "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -17513,10 +18316,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" @@ -17529,10 +18340,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" @@ -17545,10 +18364,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" @@ -17561,10 +18388,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" @@ -17577,10 +18412,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" @@ -17593,6 +18436,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -17621,6 +18468,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -17633,10 +18484,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" @@ -17649,10 +18508,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" @@ -17665,10 +18532,42 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -17681,10 +18580,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" @@ -17697,10 +18604,18 @@ "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:scripting" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -17713,10 +18628,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" @@ -17729,805 +18652,911 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "e2f3f42e" : [ + "d3d191b2" : [ { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "d6325cd7" : [ + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "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:modules:s3-repository" - } - ], - "e5b524d7" : [ + "projectPath" : ":solr:benchmark" + }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:api" + "projectPath" : ":solr:core" }, { - "configuration" : "annotationProcessor", - "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" : "annotationProcessor", - "projectPath" : ":solr:core" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", + "configuration" : "compileClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:webapp" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:server" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:solrj" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" - } - ], - "e6d93f27" : [ + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:test-framework" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "e80f7a3a" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:api" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "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", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:webapp" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:sql" }, { "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" + "projectPath" : ":solr:modules:sql" }, { "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" + } + ], + "dd724fae" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeLibs", + "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" + } + ], + "debe9836" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:s3-repository" + } + ], + "e2ba6832" : [ + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:benchmark" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:core" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:server" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:webapp" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "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" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" + } + ], + "e2f3f42e" : [ { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "annotationProcessor", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" + } + ], + "e6d93f27" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", @@ -18574,7 +19603,7 @@ "projectPath" : ":solr:modules:jwt-auth" } ], - "ebd3db47" : [ + "eaeef440" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -18615,6 +19644,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" @@ -18623,6 +19660,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "libExt", + "projectPath" : ":solr:server" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -18635,14 +19676,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" @@ -18655,6 +19708,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -18707,6 +19764,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -18719,6 +19780,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -18821,237 +19886,139 @@ }, { "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" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:monitor" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "ef8aea8b" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "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" - } - ], - "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:modules:clustering" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" - } - ], - "f7508386" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - } - ], - "f83d8628" : [ + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "ef8aea8b" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, + "projectPath" : ":solr:modules:s3-repository" + } + ], + "f19e2720" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", @@ -19062,307 +20029,277 @@ "projectPath" : ":solr:server" }, { - "configuration" : "solrCore", + "configuration" : "serverLib", "projectPath" : ":solr:server" }, { "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" }, { - "configuration" : "runtimeClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:test-framework" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, + "projectPath" : ":solr:modules:sql" + } + ], + "f493e7bb" : [ { "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:modules:gcs-repository" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:cross-dc" + } + ], + "f5acb352" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" - }, + "projectPath" : ":solr:modules:clustering" + } + ], + "f6b3fa6a" : [ { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "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" + "configuration" : "libExt", + "projectPath" : ":solr:server" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeLibs", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:sql" + } + ], + "f7508386" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" - }, + "projectPath" : ":solr:modules:hadoop-auth" + } + ], + "fa7556ff" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:prometheus-exporter" } ], - "f9ff6c21" : [ + "fc4f5282" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -19375,6 +20312,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -19383,6 +20324,10 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:core" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" @@ -19403,14 +20348,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" @@ -19431,14 +20368,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" - }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj" @@ -19447,18 +20376,10 @@ "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" @@ -19523,6 +20444,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -19535,6 +20460,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -19583,6 +20512,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -19635,6 +20568,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -19700,45 +20649,15 @@ "projectPath" : ":solr:modules:sql" } ], - "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" - } - ], - "fed35e7f" : [ + "fe67ba9c" : [ { "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" @@ -19779,26 +20698,10 @@ "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" @@ -19815,58 +20718,22 @@ "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" : "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" @@ -19907,10 +20774,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -19923,10 +20786,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -19955,10 +20814,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -19971,18 +20826,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" @@ -19995,10 +20842,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -20015,18 +20858,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" @@ -20039,10 +20874,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -20079,6 +20910,22 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:monitor" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:monitor" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -20095,10 +20942,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:s3-repository" From 698970350e4c36484076e24dde7924896939acf6 Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Sat, 23 Nov 2024 13:39:05 -0500 Subject: [PATCH 57/85] remove MonitorConstants --- .../lucene/monitor/DocumentBatchVisitor.java | 3 +- .../apache/solr/monitor/MonitorConstants.java | 27 ---------- .../search/ReverseSearchComponent.java | 53 ++++++++++--------- .../monitor/search/SyncSolrMatcherSink.java | 22 ++++---- 4 files changed, 40 insertions(+), 65 deletions(-) delete mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/DocumentBatchVisitor.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/DocumentBatchVisitor.java index 84387ce501e6..2518d5a7634f 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/DocumentBatchVisitor.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/DocumentBatchVisitor.java @@ -19,7 +19,6 @@ package org.apache.lucene.monitor; -import java.io.Closeable; import java.io.IOException; import java.util.List; import java.util.function.Supplier; @@ -28,7 +27,7 @@ import org.apache.lucene.document.Document; import org.apache.lucene.index.LeafReader; -public class DocumentBatchVisitor implements Closeable, Supplier { +public class DocumentBatchVisitor implements AutoCloseable, Supplier { private final DocumentBatch batch; private final List docs; diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java deleted file mode 100644 index 60719e6c2db8..000000000000 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorConstants.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * - * * 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.monitor; - -public class MonitorConstants { - - private MonitorConstants() {} - - public static final String MONITOR_DOCUMENTS_KEY = "monitorDocuments"; -} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index df2078236ce8..a0811d03d3f5 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -19,7 +19,6 @@ package org.apache.solr.monitor.search; -import static org.apache.solr.monitor.MonitorConstants.MONITOR_DOCUMENTS_KEY; import static org.apache.solr.monitor.search.PresearcherFactory.DEFAULT_ALIAS_PREFIX; import java.io.IOException; @@ -65,6 +64,7 @@ public class ReverseSearchComponent extends QueryComponent implements SolrCoreAw private static final String SOLR_MONITOR_CACHE_NAME_KEY = "solrMonitorCacheName"; private static final String SOLR_MONITOR_CACHE_NAME_DEFAULT = "solrMonitorCache"; + private static final String MONITOR_DOCUMENTS_KEY = "monitorDocuments"; private String solrMonitorCacheName = SOLR_MONITOR_CACHE_NAME_DEFAULT; private QueryDecomposer queryDecomposer; @@ -88,13 +88,34 @@ public void prepare(ResponseBuilder rb) throws IOException { rb.setQuery(new MatchAllDocsQuery()); - final DocumentBatchVisitor documentBatchVisitor = - documentBatchVisitor(rb.req.getJSON(), rb.req.getSchema()); - final LeafReader documentBatch = documentBatchVisitor.get(); + try (final var documentBatchVisitor = + documentBatchVisitor(rb.req.getJSON(), rb.req.getSchema())) { + final LeafReader documentBatch = documentBatchVisitor.get(); - final MonitorQueryCache monitorQueryCache = - (SharedMonitorCache) rb.req.getSearcher().getCache(this.solrMonitorCacheName); + final MonitorQueryCache monitorQueryCache = + (SharedMonitorCache) rb.req.getSearcher().getCache(this.solrMonitorCacheName); + final MonitorPostFilter monitorPostFilter = monitorPostFilter(rb, documentBatch, monitorQueryCache); + + final BiPredicate termAcceptor; + if (monitorQueryCache == null) { + termAcceptor = (__, ___) -> true; + } else { + termAcceptor = monitorQueryCache::acceptTerm; + } + final Query preFilterQuery = presearcher.buildQuery(documentBatch, termAcceptor); + + final List mutableFilters = + Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); + + mutableFilters.add(preFilterQuery); + mutableFilters.add(monitorPostFilter); + + rb.setFilters(mutableFilters); + } + } + + private static MonitorPostFilter monitorPostFilter(ResponseBuilder rb, LeafReader documentBatch, MonitorQueryCache monitorQueryCache) { final SolrMonitorQueryDecoder solrMonitorQueryDecoder = new SolrMonitorQueryDecoder(rb.req.getCore()); @@ -115,25 +136,9 @@ public void prepare(ResponseBuilder rb) throws IOException { final SolrMonitorQueryCollector.CollectorContext collectorContext = new SolrMonitorQueryCollector.CollectorContext( - monitorQueryCache, solrMonitorQueryDecoder, solrMatcherSink); - - final MonitorPostFilter monitorPostFilter = new MonitorPostFilter(collectorContext); - - final BiPredicate termAcceptor; - if (monitorQueryCache == null) { - termAcceptor = (__, ___) -> true; - } else { - termAcceptor = monitorQueryCache::acceptTerm; - } - final Query preFilterQuery = presearcher.buildQuery(documentBatch, termAcceptor); - - final List mutableFilters = - Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); - - mutableFilters.add(preFilterQuery); - mutableFilters.add(monitorPostFilter); + monitorQueryCache, solrMonitorQueryDecoder, solrMatcherSink); - rb.setFilters(mutableFilters); + return new MonitorPostFilter(collectorContext); } @SuppressWarnings({"unchecked"}) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java index a3f3b2310f02..b10ce15d2dde 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java @@ -19,32 +19,31 @@ package org.apache.solr.monitor.search; -import java.io.IOException; -import java.util.ArrayList; -import java.util.List; -import java.util.Map; -import java.util.function.Consumer; -import java.util.function.Function; import org.apache.lucene.monitor.CandidateMatcher; import org.apache.lucene.monitor.QueryMatch; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; +import java.io.IOException; +import java.util.Map; +import java.util.function.Consumer; +import java.util.function.Function; + class SyncSolrMatcherSink implements SolrMatcherSink { private final Function> matcherFactory; private final IndexSearcher docBatchSearcher; - private final Consumer> queriesConsumer; - private final List> matchers = new ArrayList<>(); + private final Consumer> sinkConsumer; + private int queriesRun; SyncSolrMatcherSink( Function> matcherFactory, IndexSearcher docBatchSearcher, - Consumer> queriesConsumer) { + Consumer> sinkConsumer) { this.matcherFactory = matcherFactory; this.docBatchSearcher = docBatchSearcher; - this.queriesConsumer = queriesConsumer; + this.sinkConsumer = sinkConsumer; } @Override @@ -52,7 +51,6 @@ public boolean matchQuery(String queryId, Query matchQuery, Map throws IOException { queriesRun++; var matcher = matcherFactory.apply(docBatchSearcher); - matchers.add(matcher); matcher.matchQuery(queryId, matchQuery, metadata); var matches = matcher.finish(Long.MIN_VALUE, 1); for (int doc = 0; doc < matches.getBatchSize(); doc++) { @@ -66,7 +64,7 @@ public boolean matchQuery(String queryId, Query matchQuery, Map @Override public void complete() { - queriesConsumer.accept(this); + sinkConsumer.accept(this); } public int getQueriesRun() { From 1e62be2b5a63b27c0e141681f8865c7d33cb1327 Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Sat, 23 Nov 2024 21:46:52 -0500 Subject: [PATCH 58/85] debug component refactor --- .../handler/component/DebugComponent.java | 42 ++++++++++--- .../search/ReverseSearchComponent.java | 35 +++++++---- .../search/ReverseSearchDebugComponent.java | 61 ------------------- .../monitor/search/ReverseSearchHandler.java | 2 + .../monitor/search/SyncSolrMatcherSink.java | 9 ++- .../solr/collection1/solrconfig-no-cache.xml | 6 +- .../collection1/solrconfig-single-core.xml | 11 +--- 7 files changed, 68 insertions(+), 98 deletions(-) delete mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchDebugComponent.java 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 e2451df3c548..71c08e212a1e 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 @@ -106,7 +106,23 @@ public void process(ResponseBuilder rb) throws IOException { info.addAll(stdinfo); } - addCustomInfo(rb, info); + FacetDebugInfo fdebug = (FacetDebugInfo) (rb.req.getContext().get("FacetDebugInfo")); + if (fdebug != null) { + info.add("facet-trace", fdebug.getFacetDebugInfo()); + } + + fdebug = (FacetDebugInfo) (rb.req.getContext().get("FacetDebugInfo-nonJson")); + if (fdebug != null) { + 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()); @@ -132,15 +148,25 @@ public void process(ResponseBuilder rb) throws IOException { } } - protected void addCustomInfo(ResponseBuilder rb, NamedList info) { - FacetDebugInfo fdebug = (FacetDebugInfo) (rb.req.getContext().get("FacetDebugInfo")); - if (fdebug != null) { - info.add("facet-trace", fdebug.getFacetDebugInfo()); + 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; - fdebug = (FacetDebugInfo) (rb.req.getContext().get("FacetDebugInfo-nonJson")); - if (fdebug != null) { - info.add("facet-debug", fdebug.getFacetDebugInfo()); + public CustomDebugInfoSource(String name, SimpleOrderedMap values) { + this.name = name; + this.values = values; } } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index a0811d03d3f5..4ea973b66f17 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -44,7 +44,9 @@ 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; @@ -89,13 +91,14 @@ public void prepare(ResponseBuilder rb) throws IOException { rb.setQuery(new MatchAllDocsQuery()); try (final var documentBatchVisitor = - documentBatchVisitor(rb.req.getJSON(), rb.req.getSchema())) { + documentBatchVisitor(rb.req.getJSON(), rb.req.getSchema())) { final LeafReader documentBatch = documentBatchVisitor.get(); final MonitorQueryCache monitorQueryCache = - (SharedMonitorCache) rb.req.getSearcher().getCache(this.solrMonitorCacheName); + (SharedMonitorCache) rb.req.getSearcher().getCache(this.solrMonitorCacheName); - final MonitorPostFilter monitorPostFilter = monitorPostFilter(rb, documentBatch, monitorQueryCache); + final MonitorPostFilter monitorPostFilter = + monitorPostFilter(rb, documentBatch, monitorQueryCache); final BiPredicate termAcceptor; if (monitorQueryCache == null) { @@ -106,7 +109,7 @@ public void prepare(ResponseBuilder rb) throws IOException { final Query preFilterQuery = presearcher.buildQuery(documentBatch, termAcceptor); final List mutableFilters = - Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); + Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); mutableFilters.add(preFilterQuery); mutableFilters.add(monitorPostFilter); @@ -115,7 +118,8 @@ public void prepare(ResponseBuilder rb) throws IOException { } } - private static MonitorPostFilter monitorPostFilter(ResponseBuilder rb, LeafReader documentBatch, MonitorQueryCache monitorQueryCache) { + private static MonitorPostFilter monitorPostFilter( + ResponseBuilder rb, LeafReader documentBatch, MonitorQueryCache monitorQueryCache) { final SolrMonitorQueryDecoder solrMonitorQueryDecoder = new SolrMonitorQueryDecoder(rb.req.getCore()); @@ -125,20 +129,25 @@ private static MonitorPostFilter monitorPostFilter(ResponseBuilder rb, LeafReade new IndexSearcher(documentBatch), matcherSink -> { if (rb.isDebug()) { - rb.req - .getContext() - .put( - ReverseSearchDebugComponent.ReverseSearchDebugInfo.KEY, - new ReverseSearchDebugComponent.ReverseSearchDebugInfo( - matcherSink.getQueriesRun())); + DebugComponent.CustomDebugInfoSources debugInfoSources = + (DebugComponent.CustomDebugInfoSources) + rb.req + .getContext() + .computeIfAbsent( + DebugComponent.CustomDebugInfoSources.KEY, + key -> new DebugComponent.CustomDebugInfoSources()); + var info = new SimpleOrderedMap<>(); + info.add("queriesRun", matcherSink.getQueriesRun()); + debugInfoSources.add( + new DebugComponent.CustomDebugInfoSource("reverse-search-debug", info)); } }); final SolrMonitorQueryCollector.CollectorContext collectorContext = new SolrMonitorQueryCollector.CollectorContext( - monitorQueryCache, solrMonitorQueryDecoder, solrMatcherSink); + monitorQueryCache, solrMonitorQueryDecoder, solrMatcherSink); - return new MonitorPostFilter(collectorContext); + return new MonitorPostFilter(collectorContext); } @SuppressWarnings({"unchecked"}) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchDebugComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchDebugComponent.java deleted file mode 100644 index 1405f5f725a9..000000000000 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchDebugComponent.java +++ /dev/null @@ -1,61 +0,0 @@ -/* - * - * * 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.monitor.search; - -import org.apache.solr.common.util.NamedList; -import org.apache.solr.common.util.SimpleOrderedMap; -import org.apache.solr.handler.component.DebugComponent; -import org.apache.solr.handler.component.ResponseBuilder; - -public class ReverseSearchDebugComponent extends DebugComponent { - public static final String COMPONENT_NAME = "reverseDebug"; - - @Override - protected void addCustomInfo(ResponseBuilder rb, NamedList info) { - super.addCustomInfo(rb, info); - ReverseSearchDebugInfo rsdebug = - (ReverseSearchDebugInfo) (rb.req.getContext().get(ReverseSearchDebugInfo.KEY)); - if (rsdebug != null) { - info.add("reverse-search-debug", rsdebug.getReverseSearchDebugInfo()); - } - } - - public static class ReverseSearchDebugInfo { - - public static final String KEY = ReverseSearchDebugInfo.class.getSimpleName(); - - private final int queriesRun; - - public ReverseSearchDebugInfo(int queriesRun) { - this.queriesRun = queriesRun; - } - - public int getQueriesRun() { - return queriesRun; - } - - public SimpleOrderedMap getReverseSearchDebugInfo() { - SimpleOrderedMap info = new SimpleOrderedMap<>(); - - info.add("queriesRun", queriesRun); - return info; - } - } -} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java index 35a89cc5658a..951a67845873 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java @@ -21,6 +21,7 @@ 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 { @@ -29,6 +30,7 @@ public class ReverseSearchHandler extends SearchHandler { 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/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java index b10ce15d2dde..a7f09751807d 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java @@ -19,15 +19,14 @@ package org.apache.solr.monitor.search; -import org.apache.lucene.monitor.CandidateMatcher; -import org.apache.lucene.monitor.QueryMatch; -import org.apache.lucene.search.IndexSearcher; -import org.apache.lucene.search.Query; - import java.io.IOException; import java.util.Map; import java.util.function.Consumer; import java.util.function.Function; +import org.apache.lucene.monitor.CandidateMatcher; +import org.apache.lucene.monitor.QueryMatch; +import org.apache.lucene.search.IndexSearcher; +import org.apache.lucene.search.Query; class SyncSolrMatcherSink implements SolrMatcherSink { diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml index cf862e8cb620..bfb0de4d082a 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml @@ -81,7 +81,11 @@ - + + + reverseSearch + + explicit diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-single-core.xml b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-single-core.xml index 044156c8f79d..78b2930273d1 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-single-core.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-single-core.xml @@ -86,12 +86,7 @@ - - - reverseSearch - reverseDebug - - + explicit @@ -134,10 +129,6 @@ 4 - - - From f840f97929dfd1862adbd26f6a8705025c8bc08b Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Mon, 25 Nov 2024 08:01:35 -0500 Subject: [PATCH 59/85] ReverseSearchQuery proof-of-concept --- .../monitor/search/MonitorPostFilter.java | 66 ---- .../search/ReverseSearchComponent.java | 59 +++- .../monitor/search/ReverseSearchQuery.java | 286 ++++++++++++++++++ .../search/SolrMonitorQueryCollector.java | 104 ------- 4 files changed, 331 insertions(+), 184 deletions(-) delete mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/MonitorPostFilter.java create mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java delete mode 100644 solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/MonitorPostFilter.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/MonitorPostFilter.java deleted file mode 100644 index d0bbf0a0eff7..000000000000 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/MonitorPostFilter.java +++ /dev/null @@ -1,66 +0,0 @@ -/* - * - * * 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.monitor.search; - -import org.apache.lucene.search.IndexSearcher; -import org.apache.lucene.search.QueryVisitor; -import org.apache.solr.search.DelegatingCollector; -import org.apache.solr.search.ExtendedQueryBase; -import org.apache.solr.search.PostFilter; - -class MonitorPostFilter extends ExtendedQueryBase implements PostFilter { - - private final SolrMonitorQueryCollector.CollectorContext collectorContext; - - MonitorPostFilter(SolrMonitorQueryCollector.CollectorContext collectorContext) { - this.collectorContext = collectorContext; - } - - @Override - public void visit(QueryVisitor visitor) { - visitor.visitLeaf(this); - } - - @Override - public DelegatingCollector getFilterCollector(IndexSearcher searcher) { - return new SolrMonitorQueryCollector(collectorContext); - } - - @Override - public boolean getCache() { - return false; - } - - @Override - public int getCost() { - // cost has to be >= 100 since we only support post filtering - return Math.max(super.getCost(), 111); - } - - @Override - public boolean equals(Object o) { - return this == o; - } - - @Override - public int hashCode() { - return System.identityHashCode(this); - } -} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 4ea973b66f17..524f910fc629 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -97,8 +97,8 @@ public void prepare(ResponseBuilder rb) throws IOException { final MonitorQueryCache monitorQueryCache = (SharedMonitorCache) rb.req.getSearcher().getCache(this.solrMonitorCacheName); - final MonitorPostFilter monitorPostFilter = - monitorPostFilter(rb, documentBatch, monitorQueryCache); +// final MonitorPostFilter monitorPostFilter = +// monitorPostFilter(rb, documentBatch, monitorQueryCache); final BiPredicate termAcceptor; if (monitorQueryCache == null) { @@ -107,19 +107,18 @@ public void prepare(ResponseBuilder rb) throws IOException { termAcceptor = monitorQueryCache::acceptTerm; } final Query preFilterQuery = presearcher.buildQuery(documentBatch, termAcceptor); + rb.setQuery(reverseSearchQuery(preFilterQuery, rb, documentBatch, monitorQueryCache)); +// final List mutableFilters = +// Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); +// +// mutableFilters.add(preFilterQuery); +// mutableFilters.add(monitorPostFilter); - final List mutableFilters = - Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); - - mutableFilters.add(preFilterQuery); - mutableFilters.add(monitorPostFilter); - - rb.setFilters(mutableFilters); +// rb.setFilters(mutableFilters); } } - private static MonitorPostFilter monitorPostFilter( - ResponseBuilder rb, LeafReader documentBatch, MonitorQueryCache monitorQueryCache) { + private static ReverseSearchQuery reverseSearchQuery(Query preFilterQuery, ResponseBuilder rb, LeafReader documentBatch, MonitorQueryCache monitorQueryCache) { final SolrMonitorQueryDecoder solrMonitorQueryDecoder = new SolrMonitorQueryDecoder(rb.req.getCore()); @@ -143,13 +142,45 @@ private static MonitorPostFilter monitorPostFilter( } }); - final SolrMonitorQueryCollector.CollectorContext collectorContext = - new SolrMonitorQueryCollector.CollectorContext( + final ReverseSearchQuery.ReverseSearchContext context = + new ReverseSearchQuery.ReverseSearchContext( monitorQueryCache, solrMonitorQueryDecoder, solrMatcherSink); - return new MonitorPostFilter(collectorContext); + return new ReverseSearchQuery(context, preFilterQuery); } +// private static MonitorPostFilter monitorPostFilter( +// ResponseBuilder rb, LeafReader documentBatch, MonitorQueryCache monitorQueryCache) { +// final SolrMonitorQueryDecoder solrMonitorQueryDecoder = +// new SolrMonitorQueryDecoder(rb.req.getCore()); +// +// final SolrMatcherSink solrMatcherSink = +// new SyncSolrMatcherSink<>( +// QueryMatch.SIMPLE_MATCHER::createMatcher, +// new IndexSearcher(documentBatch), +// matcherSink -> { +// if (rb.isDebug()) { +// DebugComponent.CustomDebugInfoSources debugInfoSources = +// (DebugComponent.CustomDebugInfoSources) +// rb.req +// .getContext() +// .computeIfAbsent( +// DebugComponent.CustomDebugInfoSources.KEY, +// key -> new DebugComponent.CustomDebugInfoSources()); +// var info = new SimpleOrderedMap<>(); +// info.add("queriesRun", matcherSink.getQueriesRun()); +// debugInfoSources.add( +// new DebugComponent.CustomDebugInfoSource("reverse-search-debug", info)); +// } +// }); +// +// final SolrMonitorQueryCollector.CollectorContext collectorContext = +// new SolrMonitorQueryCollector.CollectorContext( +// monitorQueryCache, solrMonitorQueryDecoder, solrMatcherSink); +// +// return new MonitorPostFilter(collectorContext); +// } + @SuppressWarnings({"unchecked"}) private static DocumentBatchVisitor documentBatchVisitor( Map json, IndexSchema indexSchema) { diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java new file mode 100644 index 000000000000..c546d8fc9612 --- /dev/null +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java @@ -0,0 +1,286 @@ +/* + * + * * 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.monitor.search; + +import org.apache.lucene.index.LeafReaderContext; +import org.apache.lucene.monitor.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.monitor.MonitorDataValues; +import org.apache.solr.monitor.SolrMonitorQueryDecoder; +import org.apache.solr.monitor.cache.MonitorQueryCache; +import org.apache.solr.search.ExtendedQueryBase; + +import java.io.IOException; +import java.util.Collection; +import java.util.Objects; + +class ReverseSearchQuery extends ExtendedQueryBase { + + private final ReverseSearchContext reverseSearchContext; + private Query inner; + + public ReverseSearchQuery(ReverseSearchContext reverseSearchContext, Query inner) { + this.reverseSearchContext = reverseSearchContext; + this.inner = inner; + } + + @Override + public boolean getCache() { + return false; + } + + @Override + public void visit(QueryVisitor visitor) { + inner.visit(visitor); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + ReverseSearchQuery that = (ReverseSearchQuery) o; + return Objects.equals(reverseSearchContext, that.reverseSearchContext) && Objects.equals(inner, that.inner); + } + + @Override + public Query rewrite(IndexSearcher indexSearcher) throws IOException { + Query rewritten = inner.rewrite(indexSearcher); + if (rewritten != inner){ + return new ReverseSearchQuery(reverseSearchContext, inner.rewrite(indexSearcher)); + } + return super.rewrite(indexSearcher); + } + + @Override + public int hashCode() { + return Objects.hash(reverseSearchContext, inner); + } + + @Override + public Weight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float boost) throws IOException { + return new ReverseSearchWeight(this, reverseSearchContext, inner.createWeight(searcher, scoreMode, boost)); + } + + static class ReverseSearchWeight extends Weight { + + private final ReverseSearchContext reverseSearchContext; + private final Weight innerWeight; + + ReverseSearchWeight(Query query, ReverseSearchContext reverseSearchContext, Weight innerWeight) { + super(query); + this.reverseSearchContext = reverseSearchContext; + this.innerWeight = innerWeight; + } + + @Override + public Explanation explain(LeafReaderContext context, int doc) throws IOException { + return innerWeight.explain(context, doc); + } + + @Override + public Scorer scorer(LeafReaderContext context) throws IOException { + return new ReverseSearchScorer(innerWeight.scorer(context), reverseSearchContext, context); + } + + @Override + public boolean isCacheable(LeafReaderContext ctx) { + return false; + } + + @Override + public int count(LeafReaderContext context) throws IOException { + return innerWeight.count(context); + } + + @Override + public BulkScorer bulkScorer(LeafReaderContext context) throws IOException { + return super.bulkScorer(context); + } + + @Override + public ScorerSupplier scorerSupplier(LeafReaderContext context) throws IOException { + ReverseSearchWeight weight = this; + return new ScorerSupplier() { + + @Override + public Scorer get(long leadCost) throws IOException { + return weight.scorer(context); + } + + @Override + public long cost() { + return Long.MAX_VALUE; + } + }; + } + + @Override + public Matches matches(LeafReaderContext context, int doc) throws IOException { + return innerWeight.matches(context, doc); + } + } + + static class ReverseSearchScorer extends Scorer { + private static final float MATCH_COST = 100.0f; + + private final Scorer inner; + private final MonitorQueryCache monitorQueryCache; + private final SolrMonitorQueryDecoder queryDecoder; + private final SolrMatcherSink matcherSink; + private final MonitorDataValues dataValues = new MonitorDataValues(); + + ReverseSearchScorer(Scorer inner, ReverseSearchContext reverseSearchContext, LeafReaderContext leafReaderContext) throws IOException { + super(inner.getWeight()); + this.inner = inner; + this.monitorQueryCache = reverseSearchContext.queryCache; + this.queryDecoder = reverseSearchContext.queryDecoder; + this.matcherSink = reverseSearchContext.solrMatcherSink; + this.dataValues.update(leafReaderContext); + } + + @Override + public DocIdSetIterator iterator() { + return inner.iterator(); + } + + @Override + public float getMaxScore(int upTo) throws IOException { + return inner.getMaxScore(upTo); + } + + @Override + public float score() throws IOException { + return inner.score(); + } + + @Override + public int docID() { + return inner.docID(); + } + + @Override + public Weight getWeight() { + return inner.getWeight(); + } + + @Override + public int advanceShallow(int target) throws IOException { + return inner.advanceShallow(target); + } + + @Override + public float smoothingScore(int docId) throws IOException { + return inner.smoothingScore(docId); + } + + @Override + public void setMinCompetitiveScore(float minScore) throws IOException { + inner.setMinCompetitiveScore(minScore); + } + + @Override + public Collection getChildren() throws IOException { + return inner.getChildren(); + } + + @Override + public TwoPhaseIterator twoPhaseIterator() { + + return new TwoPhaseIterator(inner.iterator()) { + + private String lastQueryId; + + @Override + public boolean matches() throws IOException { + 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(MonitorDataValues dataValues) throws IOException { + var versionedEntry = + monitorQueryCache == null + ? null + : monitorQueryCache.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 MonitorQueryCache queryCache; + private final SolrMonitorQueryDecoder queryDecoder; + private final SolrMatcherSink solrMatcherSink; + + ReverseSearchContext( + MonitorQueryCache queryCache, + SolrMonitorQueryDecoder queryDecoder, + SolrMatcherSink solrMatcherSink) { + this.queryCache = queryCache; + this.queryDecoder = queryDecoder; + this.solrMatcherSink = solrMatcherSink; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + ReverseSearchContext that = (ReverseSearchContext) o; + return Objects.equals(queryCache, that.queryCache) && Objects.equals(queryDecoder, that.queryDecoder) && Objects.equals(solrMatcherSink, that.solrMatcherSink); + } + + @Override + public int hashCode() { + return Objects.hash(queryCache, queryDecoder, solrMatcherSink); + } + } +} diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java deleted file mode 100644 index 9b570a5b0327..000000000000 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMonitorQueryCollector.java +++ /dev/null @@ -1,104 +0,0 @@ -/* - * - * * 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.monitor.search; - -import java.io.IOException; -import org.apache.lucene.index.LeafReaderContext; -import org.apache.lucene.monitor.QCEVisitor; -import org.apache.lucene.search.ConstantScoreQuery; -import org.apache.lucene.search.ScoreMode; -import org.apache.solr.monitor.MonitorDataValues; -import org.apache.solr.monitor.SolrMonitorQueryDecoder; -import org.apache.solr.monitor.cache.MonitorQueryCache; -import org.apache.solr.search.DelegatingCollector; - -class SolrMonitorQueryCollector extends DelegatingCollector { - - private final MonitorQueryCache monitorQueryCache; - private final SolrMonitorQueryDecoder queryDecoder; - private final SolrMatcherSink matcherSink; - private final MonitorDataValues dataValues = new MonitorDataValues(); - private String lastQueryId; - - SolrMonitorQueryCollector(CollectorContext collectorContext) { - this.monitorQueryCache = collectorContext.queryCache; - this.queryDecoder = collectorContext.queryDecoder; - this.matcherSink = collectorContext.solrMatcherSink; - } - - @Override - public void collect(int doc) throws IOException { - 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; - super.collect(doc); - } - } - - private QCEVisitor getEntry(MonitorDataValues dataValues) throws IOException { - var versionedEntry = - monitorQueryCache == null - ? null - : monitorQueryCache.computeIfStale(dataValues, queryDecoder); - return (versionedEntry == null || versionedEntry.version != dataValues.getVersion()) - ? queryDecoder.getComponent(dataValues, dataValues.getCacheId()) - : versionedEntry.entry; - } - - @Override - public void doSetNextReader(LeafReaderContext context) throws IOException { - super.doSetNextReader(context); - dataValues.update(context); - } - - @Override - public ScoreMode scoreMode() { - return ScoreMode.COMPLETE_NO_SCORES; - } - - @Override - public void complete() throws IOException { - super.finish(); - matcherSink.complete(); - } - - static class CollectorContext { - - private final MonitorQueryCache queryCache; - private final SolrMonitorQueryDecoder queryDecoder; - private final SolrMatcherSink solrMatcherSink; - - CollectorContext( - MonitorQueryCache queryCache, - SolrMonitorQueryDecoder queryDecoder, - SolrMatcherSink solrMatcherSink) { - this.queryCache = queryCache; - this.queryDecoder = queryDecoder; - this.solrMatcherSink = solrMatcherSink; - } - } -} From 4cc04c4e7558818484d9facecf40e1d785f2b84d Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Mon, 25 Nov 2024 08:28:23 -0500 Subject: [PATCH 60/85] handle null scorer --- .../search/ReverseSearchComponent.java | 42 ----------- .../monitor/search/ReverseSearchQuery.java | 75 ++++++++++--------- 2 files changed, 41 insertions(+), 76 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 524f910fc629..61280bf50b10 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -97,9 +97,6 @@ public void prepare(ResponseBuilder rb) throws IOException { final MonitorQueryCache monitorQueryCache = (SharedMonitorCache) rb.req.getSearcher().getCache(this.solrMonitorCacheName); -// final MonitorPostFilter monitorPostFilter = -// monitorPostFilter(rb, documentBatch, monitorQueryCache); - final BiPredicate termAcceptor; if (monitorQueryCache == null) { termAcceptor = (__, ___) -> true; @@ -108,13 +105,6 @@ public void prepare(ResponseBuilder rb) throws IOException { } final Query preFilterQuery = presearcher.buildQuery(documentBatch, termAcceptor); rb.setQuery(reverseSearchQuery(preFilterQuery, rb, documentBatch, monitorQueryCache)); -// final List mutableFilters = -// Optional.ofNullable(rb.getFilters()).map(ArrayList::new).orElseGet(ArrayList::new); -// -// mutableFilters.add(preFilterQuery); -// mutableFilters.add(monitorPostFilter); - -// rb.setFilters(mutableFilters); } } @@ -149,38 +139,6 @@ private static ReverseSearchQuery reverseSearchQuery(Query preFilterQuery, Respo return new ReverseSearchQuery(context, preFilterQuery); } -// private static MonitorPostFilter monitorPostFilter( -// ResponseBuilder rb, LeafReader documentBatch, MonitorQueryCache monitorQueryCache) { -// final SolrMonitorQueryDecoder solrMonitorQueryDecoder = -// new SolrMonitorQueryDecoder(rb.req.getCore()); -// -// final SolrMatcherSink solrMatcherSink = -// new SyncSolrMatcherSink<>( -// QueryMatch.SIMPLE_MATCHER::createMatcher, -// new IndexSearcher(documentBatch), -// matcherSink -> { -// if (rb.isDebug()) { -// DebugComponent.CustomDebugInfoSources debugInfoSources = -// (DebugComponent.CustomDebugInfoSources) -// rb.req -// .getContext() -// .computeIfAbsent( -// DebugComponent.CustomDebugInfoSources.KEY, -// key -> new DebugComponent.CustomDebugInfoSources()); -// var info = new SimpleOrderedMap<>(); -// info.add("queriesRun", matcherSink.getQueriesRun()); -// debugInfoSources.add( -// new DebugComponent.CustomDebugInfoSource("reverse-search-debug", info)); -// } -// }); -// -// final SolrMonitorQueryCollector.CollectorContext collectorContext = -// new SolrMonitorQueryCollector.CollectorContext( -// monitorQueryCache, solrMonitorQueryDecoder, solrMatcherSink); -// -// return new MonitorPostFilter(collectorContext); -// } - @SuppressWarnings({"unchecked"}) private static DocumentBatchVisitor documentBatchVisitor( Map json, IndexSchema indexSchema) { diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java index c546d8fc9612..d57666042b0d 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java @@ -46,11 +46,11 @@ class ReverseSearchQuery extends ExtendedQueryBase { private final ReverseSearchContext reverseSearchContext; - private Query inner; + private final Query presearchQuery; - public ReverseSearchQuery(ReverseSearchContext reverseSearchContext, Query inner) { + public ReverseSearchQuery(ReverseSearchContext reverseSearchContext, Query presearchQuery) { this.reverseSearchContext = reverseSearchContext; - this.inner = inner; + this.presearchQuery = presearchQuery; } @Override @@ -60,7 +60,7 @@ public boolean getCache() { @Override public void visit(QueryVisitor visitor) { - inner.visit(visitor); + presearchQuery.visit(visitor); } @Override @@ -68,47 +68,51 @@ public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; ReverseSearchQuery that = (ReverseSearchQuery) o; - return Objects.equals(reverseSearchContext, that.reverseSearchContext) && Objects.equals(inner, that.inner); + return Objects.equals(reverseSearchContext, that.reverseSearchContext) && Objects.equals(presearchQuery, that.presearchQuery); } @Override public Query rewrite(IndexSearcher indexSearcher) throws IOException { - Query rewritten = inner.rewrite(indexSearcher); - if (rewritten != inner){ - return new ReverseSearchQuery(reverseSearchContext, inner.rewrite(indexSearcher)); + Query rewritten = presearchQuery.rewrite(indexSearcher); + if (rewritten != presearchQuery){ + return new ReverseSearchQuery(reverseSearchContext, presearchQuery.rewrite(indexSearcher)); } return super.rewrite(indexSearcher); } @Override public int hashCode() { - return Objects.hash(reverseSearchContext, inner); + return Objects.hash(reverseSearchContext, presearchQuery); } @Override public Weight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float boost) throws IOException { - return new ReverseSearchWeight(this, reverseSearchContext, inner.createWeight(searcher, scoreMode, boost)); + return new ReverseSearchWeight(this, reverseSearchContext, presearchQuery.createWeight(searcher, scoreMode, boost)); } static class ReverseSearchWeight extends Weight { private final ReverseSearchContext reverseSearchContext; - private final Weight innerWeight; + private final Weight presearchWeight; - ReverseSearchWeight(Query query, ReverseSearchContext reverseSearchContext, Weight innerWeight) { + ReverseSearchWeight(Query query, ReverseSearchContext reverseSearchContext, Weight presearchWeight) { super(query); this.reverseSearchContext = reverseSearchContext; - this.innerWeight = innerWeight; + this.presearchWeight = presearchWeight; } @Override public Explanation explain(LeafReaderContext context, int doc) throws IOException { - return innerWeight.explain(context, doc); + return presearchWeight.explain(context, doc); } @Override public Scorer scorer(LeafReaderContext context) throws IOException { - return new ReverseSearchScorer(innerWeight.scorer(context), reverseSearchContext, context); + Scorer scorer = presearchWeight.scorer(context); + if (scorer == null) { + return null; + } + return new ReverseSearchScorer(scorer, reverseSearchContext, context); } @Override @@ -118,7 +122,7 @@ public boolean isCacheable(LeafReaderContext ctx) { @Override public int count(LeafReaderContext context) throws IOException { - return innerWeight.count(context); + return presearchWeight.count(context); } @Override @@ -128,12 +132,15 @@ public BulkScorer bulkScorer(LeafReaderContext context) throws IOException { @Override public ScorerSupplier scorerSupplier(LeafReaderContext context) throws IOException { - ReverseSearchWeight weight = this; + Scorer scorer = scorer(context); + if (scorer == null) { + return null; + } return new ScorerSupplier() { @Override - public Scorer get(long leadCost) throws IOException { - return weight.scorer(context); + public Scorer get(long leadCost) { + return scorer; } @Override @@ -145,22 +152,22 @@ public long cost() { @Override public Matches matches(LeafReaderContext context, int doc) throws IOException { - return innerWeight.matches(context, doc); + return presearchWeight.matches(context, doc); } } static class ReverseSearchScorer extends Scorer { private static final float MATCH_COST = 100.0f; - private final Scorer inner; + private final Scorer presearchScorer; private final MonitorQueryCache monitorQueryCache; private final SolrMonitorQueryDecoder queryDecoder; private final SolrMatcherSink matcherSink; private final MonitorDataValues dataValues = new MonitorDataValues(); - ReverseSearchScorer(Scorer inner, ReverseSearchContext reverseSearchContext, LeafReaderContext leafReaderContext) throws IOException { - super(inner.getWeight()); - this.inner = inner; + ReverseSearchScorer(Scorer presearchScorer, ReverseSearchContext reverseSearchContext, LeafReaderContext leafReaderContext) throws IOException { + super(presearchScorer.getWeight()); + this.presearchScorer = presearchScorer; this.monitorQueryCache = reverseSearchContext.queryCache; this.queryDecoder = reverseSearchContext.queryDecoder; this.matcherSink = reverseSearchContext.solrMatcherSink; @@ -169,53 +176,53 @@ static class ReverseSearchScorer extends Scorer { @Override public DocIdSetIterator iterator() { - return inner.iterator(); + return presearchScorer.iterator(); } @Override public float getMaxScore(int upTo) throws IOException { - return inner.getMaxScore(upTo); + return presearchScorer.getMaxScore(upTo); } @Override public float score() throws IOException { - return inner.score(); + return presearchScorer.score(); } @Override public int docID() { - return inner.docID(); + return presearchScorer.docID(); } @Override public Weight getWeight() { - return inner.getWeight(); + return presearchScorer.getWeight(); } @Override public int advanceShallow(int target) throws IOException { - return inner.advanceShallow(target); + return presearchScorer.advanceShallow(target); } @Override public float smoothingScore(int docId) throws IOException { - return inner.smoothingScore(docId); + return presearchScorer.smoothingScore(docId); } @Override public void setMinCompetitiveScore(float minScore) throws IOException { - inner.setMinCompetitiveScore(minScore); + presearchScorer.setMinCompetitiveScore(minScore); } @Override public Collection getChildren() throws IOException { - return inner.getChildren(); + return presearchScorer.getChildren(); } @Override public TwoPhaseIterator twoPhaseIterator() { - return new TwoPhaseIterator(inner.iterator()) { + return new TwoPhaseIterator(presearchScorer.iterator()) { private String lastQueryId; From e68c32989986b489ffbe3cd2574fdb7ec426c2d3 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Mon, 25 Nov 2024 18:53:53 -0500 Subject: [PATCH 61/85] wire lucene-monitor metadata to solr response --- .../solr/monitor/MonitorDataValues.java | 14 +- .../SharedMonitorCacheLatestRegenerator.java | 3 +- .../search/ReverseSearchComponent.java | 46 +- .../monitor/search/ReverseSearchQuery.java | 418 ++++++++++-------- .../solr/monitor/search/SolrMatcherSink.java | 4 +- .../monitor/search/SyncSolrMatcherSink.java | 23 +- .../monitor/SingleCoreMonitorSolrTest.java | 2 + 7 files changed, 274 insertions(+), 236 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java index b75073ce91ee..7dcfd3ae226b 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java @@ -30,14 +30,14 @@ public class MonitorDataValues { - private SortedDocValues queryIdIt; - private SortedDocValues cacheIdIt; - private SortedDocValues mqIt; - private NumericDocValues versionIt; - private int currentDoc = DocIdSetIterator.NO_MORE_DOCS; - private LeafReader reader; + private final SortedDocValues queryIdIt; + private final SortedDocValues cacheIdIt; + private final SortedDocValues mqIt; + private final NumericDocValues versionIt; + private final LeafReader reader; + private int currentDoc; - public void update(LeafReaderContext context) throws IOException { + public MonitorDataValues(LeafReaderContext context) throws IOException { reader = context.reader(); cacheIdIt = reader.getSortedDocValues(MonitorFields.CACHE_ID); queryIdIt = reader.getSortedDocValues(MonitorFields.QUERY_ID); diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java index 08e585c0fb97..689558df3cfe 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java @@ -58,11 +58,10 @@ public boolean regenerateItem( .scoreDocs; int batchesRemaining = cache.getInitialSize() / batchSize - 1; SolrMonitorQueryDecoder decoder = new SolrMonitorQueryDecoder(searcher.getCore()); - MonitorDataValues dataValues = new MonitorDataValues(); while (topDocs.length > 0 && batchesRemaining > 0) { int docIndex = 0; for (LeafReaderContext ctx : reader.leaves()) { - dataValues.update(ctx); + MonitorDataValues dataValues = new MonitorDataValues(ctx); int shiftedMax = ctx.reader().maxDoc() + ctx.docBase; while (docIndex < topDocs.length && topDocs[docIndex].doc >= ctx.docBase diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index 61280bf50b10..c57625383e2d 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -27,7 +27,6 @@ import java.util.Comparator; import java.util.List; import java.util.Map; -import java.util.Optional; import java.util.UUID; import java.util.function.BiPredicate; import org.apache.lucene.document.Document; @@ -108,29 +107,18 @@ public void prepare(ResponseBuilder rb) throws IOException { } } - private static ReverseSearchQuery reverseSearchQuery(Query preFilterQuery, ResponseBuilder rb, LeafReader documentBatch, MonitorQueryCache monitorQueryCache) { + private static ReverseSearchQuery reverseSearchQuery( + Query preFilterQuery, + ResponseBuilder rb, + LeafReader documentBatch, + MonitorQueryCache monitorQueryCache) { final SolrMonitorQueryDecoder solrMonitorQueryDecoder = new SolrMonitorQueryDecoder(rb.req.getCore()); final SolrMatcherSink solrMatcherSink = new SyncSolrMatcherSink<>( - QueryMatch.SIMPLE_MATCHER::createMatcher, - new IndexSearcher(documentBatch), - matcherSink -> { - if (rb.isDebug()) { - DebugComponent.CustomDebugInfoSources debugInfoSources = - (DebugComponent.CustomDebugInfoSources) - rb.req - .getContext() - .computeIfAbsent( - DebugComponent.CustomDebugInfoSources.KEY, - key -> new DebugComponent.CustomDebugInfoSources()); - var info = new SimpleOrderedMap<>(); - info.add("queriesRun", matcherSink.getQueriesRun()); - debugInfoSources.add( - new DebugComponent.CustomDebugInfoSource("reverse-search-debug", info)); - } - }); + QueryMatch.SIMPLE_MATCHER::createMatcher, new IndexSearcher(documentBatch)); + rb.req.getContext().put(SolrMatcherSink.class.getSimpleName(), solrMatcherSink); final ReverseSearchQuery.ReverseSearchContext context = new ReverseSearchQuery.ReverseSearchContext( @@ -139,6 +127,26 @@ private static ReverseSearchQuery reverseSearchQuery(Query preFilterQuery, Respo 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()); + var 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) { diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java index d57666042b0d..005ea719ff25 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java @@ -19,6 +19,9 @@ package org.apache.solr.monitor.search; +import java.io.IOException; +import java.util.Collection; +import java.util.Objects; import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.monitor.QCEVisitor; import org.apache.lucene.search.BulkScorer; @@ -39,255 +42,282 @@ import org.apache.solr.monitor.cache.MonitorQueryCache; import org.apache.solr.search.ExtendedQueryBase; -import java.io.IOException; -import java.util.Collection; -import java.util.Objects; - class ReverseSearchQuery extends ExtendedQueryBase { + private final ReverseSearchContext reverseSearchContext; + private final Query presearchQuery; + + public ReverseSearchQuery(ReverseSearchContext reverseSearchContext, Query presearchQuery) { + this.reverseSearchContext = reverseSearchContext; + this.presearchQuery = presearchQuery; + } + + @Override + public boolean getCache() { + return false; + } + + @Override + public void visit(QueryVisitor visitor) { + presearchQuery.visit(visitor); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + ReverseSearchQuery that = (ReverseSearchQuery) o; + return Objects.equals(reverseSearchContext, that.reverseSearchContext) + && Objects.equals(presearchQuery, that.presearchQuery); + } + + @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 Objects.hash(reverseSearchContext, presearchQuery); + } + + @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 Query presearchQuery; + private final Weight presearchWeight; - public ReverseSearchQuery(ReverseSearchContext reverseSearchContext, Query presearchQuery) { - this.reverseSearchContext = reverseSearchContext; - this.presearchQuery = presearchQuery; + ReverseSearchWeight( + Query query, ReverseSearchContext reverseSearchContext, Weight presearchWeight) { + super(query); + this.reverseSearchContext = reverseSearchContext; + this.presearchWeight = presearchWeight; } @Override - public boolean getCache() { - return false; + public Explanation explain(LeafReaderContext context, int doc) throws IOException { + return presearchWeight.explain(context, doc); } @Override - public void visit(QueryVisitor visitor) { - presearchQuery.visit(visitor); + 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 equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - ReverseSearchQuery that = (ReverseSearchQuery) o; - return Objects.equals(reverseSearchContext, that.reverseSearchContext) && Objects.equals(presearchQuery, that.presearchQuery); + public boolean isCacheable(LeafReaderContext ctx) { + return false; } @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); + public int count(LeafReaderContext context) throws IOException { + return presearchWeight.count(context); } @Override - public int hashCode() { - return Objects.hash(reverseSearchContext, presearchQuery); + public BulkScorer bulkScorer(LeafReaderContext context) throws IOException { + return super.bulkScorer(context); } @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; - } + public ScorerSupplier scorerSupplier(LeafReaderContext context) throws IOException { + Scorer scorer = scorer(context); + if (scorer == null) { + return null; + } + return new ScorerSupplier() { @Override - public Explanation explain(LeafReaderContext context, int doc) throws IOException { - return presearchWeight.explain(context, doc); + public Scorer get(long leadCost) { + return scorer; } @Override - public Scorer scorer(LeafReaderContext context) throws IOException { - Scorer scorer = presearchWeight.scorer(context); - if (scorer == null) { - return null; - } - return new ReverseSearchScorer(scorer, reverseSearchContext, context); + public long cost() { + return Long.MAX_VALUE; } + }; + } - @Override - public boolean isCacheable(LeafReaderContext ctx) { - return false; - } + @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 MonitorQueryCache monitorQueryCache; + private final SolrMonitorQueryDecoder queryDecoder; + private final SolrMatcherSink matcherSink; + private final Metadata metadata; + private final MonitorDataValues dataValues; + + ReverseSearchScorer( + Scorer presearchScorer, + ReverseSearchContext reverseSearchContext, + LeafReaderContext leafReaderContext) + throws IOException { + super(presearchScorer.getWeight()); + this.presearchScorer = presearchScorer; + this.monitorQueryCache = reverseSearchContext.queryCache; + this.queryDecoder = reverseSearchContext.queryDecoder; + this.matcherSink = reverseSearchContext.solrMatcherSink; + this.metadata = new Metadata(); + matcherSink.captureMetadata(metadata); + this.dataValues = new MonitorDataValues(leafReaderContext); + } - @Override - public int count(LeafReaderContext context) throws IOException { - return presearchWeight.count(context); - } + @Override + public DocIdSetIterator iterator() { + return presearchScorer.iterator(); + } - @Override - public BulkScorer bulkScorer(LeafReaderContext context) throws IOException { - return super.bulkScorer(context); - } + @Override + public float getMaxScore(int upTo) throws IOException { + return presearchScorer.getMaxScore(upTo); + } - @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 float score() throws IOException { + return presearchScorer.score(); + } - @Override - public Matches matches(LeafReaderContext context, int doc) throws IOException { - return presearchWeight.matches(context, doc); - } + @Override + public int docID() { + return presearchScorer.docID(); } - static class ReverseSearchScorer extends Scorer { - private static final float MATCH_COST = 100.0f; - - private final Scorer presearchScorer; - private final MonitorQueryCache monitorQueryCache; - private final SolrMonitorQueryDecoder queryDecoder; - private final SolrMatcherSink matcherSink; - private final MonitorDataValues dataValues = new MonitorDataValues(); - - ReverseSearchScorer(Scorer presearchScorer, ReverseSearchContext reverseSearchContext, LeafReaderContext leafReaderContext) throws IOException { - super(presearchScorer.getWeight()); - this.presearchScorer = presearchScorer; - this.monitorQueryCache = reverseSearchContext.queryCache; - this.queryDecoder = reverseSearchContext.queryDecoder; - this.matcherSink = reverseSearchContext.solrMatcherSink; - this.dataValues.update(leafReaderContext); - } + @Override + public Weight getWeight() { + return presearchScorer.getWeight(); + } - @Override - public DocIdSetIterator iterator() { - return presearchScorer.iterator(); - } + @Override + public int advanceShallow(int target) throws IOException { + return presearchScorer.advanceShallow(target); + } - @Override - public float getMaxScore(int upTo) throws IOException { - return presearchScorer.getMaxScore(upTo); - } + @Override + public float smoothingScore(int docId) throws IOException { + return presearchScorer.smoothingScore(docId); + } - @Override - public float score() throws IOException { - return presearchScorer.score(); - } + @Override + public void setMinCompetitiveScore(float minScore) throws IOException { + presearchScorer.setMinCompetitiveScore(minScore); + } - @Override - public int docID() { - return presearchScorer.docID(); - } + @Override + public Collection getChildren() throws IOException { + return presearchScorer.getChildren(); + } - @Override - public Weight getWeight() { - return presearchScorer.getWeight(); - } + @Override + public TwoPhaseIterator twoPhaseIterator() { - @Override - public int advanceShallow(int target) throws IOException { - return presearchScorer.advanceShallow(target); - } + return new TwoPhaseIterator(presearchScorer.iterator()) { - @Override - public float smoothingScore(int docId) throws IOException { - return presearchScorer.smoothingScore(docId); - } + private String lastQueryId; @Override - public void setMinCompetitiveScore(float minScore) throws IOException { - presearchScorer.setMinCompetitiveScore(minScore); + 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; } - @Override - public Collection getChildren() throws IOException { - return presearchScorer.getChildren(); + private QCEVisitor getEntry(MonitorDataValues dataValues) throws IOException { + var versionedEntry = + monitorQueryCache == null + ? null + : monitorQueryCache.computeIfStale(dataValues, queryDecoder); + return (versionedEntry == null || versionedEntry.version != dataValues.getVersion()) + ? queryDecoder.getComponent(dataValues, dataValues.getCacheId()) + : versionedEntry.entry; } @Override - public TwoPhaseIterator twoPhaseIterator() { - - return new TwoPhaseIterator(presearchScorer.iterator()) { - - private String lastQueryId; - - @Override - public boolean matches() throws IOException { - 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(MonitorDataValues dataValues) throws IOException { - var versionedEntry = - monitorQueryCache == null - ? null - : monitorQueryCache.computeIfStale(dataValues, queryDecoder); - return (versionedEntry == null || versionedEntry.version != dataValues.getVersion()) - ? queryDecoder.getComponent(dataValues, dataValues.getCacheId()) - : versionedEntry.entry; - } - - @Override - public float matchCost() { - return MATCH_COST; - } - }; + public float matchCost() { + return MATCH_COST; } + }; } + } - static class ReverseSearchContext { + static class ReverseSearchContext { - private final MonitorQueryCache queryCache; - private final SolrMonitorQueryDecoder queryDecoder; - private final SolrMatcherSink solrMatcherSink; + private final MonitorQueryCache queryCache; + private final SolrMonitorQueryDecoder queryDecoder; + private final SolrMatcherSink solrMatcherSink; - ReverseSearchContext( - MonitorQueryCache queryCache, - SolrMonitorQueryDecoder queryDecoder, - SolrMatcherSink solrMatcherSink) { - this.queryCache = queryCache; - this.queryDecoder = queryDecoder; - this.solrMatcherSink = solrMatcherSink; - } + ReverseSearchContext( + MonitorQueryCache queryCache, + SolrMonitorQueryDecoder queryDecoder, + SolrMatcherSink solrMatcherSink) { + this.queryCache = queryCache; + this.queryDecoder = queryDecoder; + this.solrMatcherSink = solrMatcherSink; + } - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - ReverseSearchContext that = (ReverseSearchContext) o; - return Objects.equals(queryCache, that.queryCache) && Objects.equals(queryDecoder, that.queryDecoder) && Objects.equals(solrMatcherSink, that.solrMatcherSink); - } + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + ReverseSearchContext that = (ReverseSearchContext) o; + return Objects.equals(queryCache, that.queryCache) + && Objects.equals(queryDecoder, that.queryDecoder) + && Objects.equals(solrMatcherSink, that.solrMatcherSink); + } - @Override - public int hashCode() { - return Objects.hash(queryCache, queryDecoder, solrMatcherSink); - } + @Override + public int hashCode() { + return Objects.hash(queryCache, queryDecoder, 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/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java index 4a0d7317f68c..d1718c6914e0 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java @@ -28,5 +28,7 @@ interface SolrMatcherSink { boolean matchQuery(String queryId, Query matchQuery, Map metadata) throws IOException; - void complete() throws IOException; + void captureMetadata(ReverseSearchQuery.Metadata metadata); + + ReverseSearchQuery.Metadata getMetadata(); } diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java index a7f09751807d..a4bf19a4266d 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java @@ -21,7 +21,7 @@ import java.io.IOException; import java.util.Map; -import java.util.function.Consumer; +import java.util.concurrent.ConcurrentHashMap; import java.util.function.Function; import org.apache.lucene.monitor.CandidateMatcher; import org.apache.lucene.monitor.QueryMatch; @@ -32,23 +32,18 @@ class SyncSolrMatcherSink implements SolrMatcherSink { private final Function> matcherFactory; private final IndexSearcher docBatchSearcher; - private final Consumer> sinkConsumer; - - private int queriesRun; + private final ConcurrentHashMap.KeySetView metadataSet = + ConcurrentHashMap.newKeySet(); SyncSolrMatcherSink( - Function> matcherFactory, - IndexSearcher docBatchSearcher, - Consumer> sinkConsumer) { + Function> matcherFactory, IndexSearcher docBatchSearcher) { this.matcherFactory = matcherFactory; this.docBatchSearcher = docBatchSearcher; - this.sinkConsumer = sinkConsumer; } @Override public boolean matchQuery(String queryId, Query matchQuery, Map metadata) throws IOException { - queriesRun++; var matcher = matcherFactory.apply(docBatchSearcher); matcher.matchQuery(queryId, matchQuery, metadata); var matches = matcher.finish(Long.MIN_VALUE, 1); @@ -62,11 +57,13 @@ public boolean matchQuery(String queryId, Query matchQuery, Map } @Override - public void complete() { - sinkConsumer.accept(this); + public void captureMetadata(ReverseSearchQuery.Metadata metadata) { + metadataSet.add(metadata); } - public int getQueriesRun() { - return queriesRun; + @Override + public ReverseSearchQuery.Metadata getMetadata() { + return metadataSet.stream() + .reduce(ReverseSearchQuery.Metadata.IDENTITY, ReverseSearchQuery.Metadata::add); } } diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java b/solr/modules/monitor/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java index e2fab831a00e..31d8bf05af2d 100644 --- a/solr/modules/monitor/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java +++ b/solr/modules/monitor/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java @@ -188,6 +188,8 @@ public void manySegmentsQuery() throws Exception { CommonParams.QT, "/reverseSearch", CommonParams.DEBUG_QUERY, + "true", + "multiThreaded", "true" }; From c1d3f726eaad94446e7a74c7f45f567a00b82610 Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Thu, 28 Nov 2024 21:17:07 -0500 Subject: [PATCH 62/85] simplify interface and implement toString --- .../monitor/search/ReverseSearchQuery.java | 40 +++++-------------- 1 file changed, 11 insertions(+), 29 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java index 005ea719ff25..9120c8170c11 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java @@ -21,7 +21,6 @@ import java.io.IOException; import java.util.Collection; -import java.util.Objects; import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.monitor.QCEVisitor; import org.apache.lucene.search.BulkScorer; @@ -40,9 +39,8 @@ import org.apache.solr.monitor.MonitorDataValues; import org.apache.solr.monitor.SolrMonitorQueryDecoder; import org.apache.solr.monitor.cache.MonitorQueryCache; -import org.apache.solr.search.ExtendedQueryBase; -class ReverseSearchQuery extends ExtendedQueryBase { +class ReverseSearchQuery extends Query { private final ReverseSearchContext reverseSearchContext; private final Query presearchQuery; @@ -52,11 +50,6 @@ public ReverseSearchQuery(ReverseSearchContext reverseSearchContext, Query prese this.presearchQuery = presearchQuery; } - @Override - public boolean getCache() { - return false; - } - @Override public void visit(QueryVisitor visitor) { presearchQuery.visit(visitor); @@ -64,11 +57,7 @@ public void visit(QueryVisitor visitor) { @Override public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - ReverseSearchQuery that = (ReverseSearchQuery) o; - return Objects.equals(reverseSearchContext, that.reverseSearchContext) - && Objects.equals(presearchQuery, that.presearchQuery); + return this == o; } @Override @@ -82,7 +71,15 @@ public Query rewrite(IndexSearcher indexSearcher) throws IOException { @Override public int hashCode() { - return Objects.hash(reverseSearchContext, presearchQuery); + return System.identityHashCode(this); + } + + @Override + public String toString(String field) { + return this.getClass().getSimpleName() + + "(presearchQuery=" + + presearchQuery.toString(field) + + ")"; } @Override @@ -287,21 +284,6 @@ static class ReverseSearchContext { this.queryDecoder = queryDecoder; this.solrMatcherSink = solrMatcherSink; } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - ReverseSearchContext that = (ReverseSearchContext) o; - return Objects.equals(queryCache, that.queryCache) - && Objects.equals(queryDecoder, that.queryDecoder) - && Objects.equals(solrMatcherSink, that.solrMatcherSink); - } - - @Override - public int hashCode() { - return Objects.hash(queryCache, queryDecoder, solrMatcherSink); - } } static class Metadata { From 42e5f448364560b77a90ccc16f9305b9902a7c82 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Sun, 1 Dec 2024 19:38:53 -0500 Subject: [PATCH 63/85] clean up --- .../monitor/search/ReverseSearchComponent.java | 16 ++++++---------- .../solr/collection1/schema-aliasing.xml | 5 +---- .../solr/collection1/schema-stored-mq.xml | 3 --- .../src/test-files/solr/collection1/schema.xml | 4 ---- 4 files changed, 7 insertions(+), 21 deletions(-) diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java index c57625383e2d..4687b0162c28 100644 --- a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java @@ -38,7 +38,6 @@ import org.apache.lucene.monitor.QueryMatch; import org.apache.lucene.monitor.TermFilteredPresearcher; import org.apache.lucene.search.IndexSearcher; -import org.apache.lucene.search.MatchAllDocsQuery; import org.apache.lucene.search.Query; import org.apache.lucene.util.BytesRef; import org.apache.solr.common.SolrException; @@ -86,10 +85,7 @@ public void init(NamedList args) { @Override public void prepare(ResponseBuilder rb) throws IOException { super.prepare(rb); - - rb.setQuery(new MatchAllDocsQuery()); - - try (final var documentBatchVisitor = + try (final DocumentBatchVisitor documentBatchVisitor = documentBatchVisitor(rb.req.getJSON(), rb.req.getSchema())) { final LeafReader documentBatch = documentBatchVisitor.get(); @@ -141,7 +137,7 @@ public void process(ResponseBuilder rb) throws IOException { .computeIfAbsent( DebugComponent.CustomDebugInfoSources.KEY, key -> new DebugComponent.CustomDebugInfoSources()); - var info = new SimpleOrderedMap<>(); + SimpleOrderedMap info = new SimpleOrderedMap<>(); info.add("queriesRun", metadata.getQueriesRun()); debugInfoSources.add(new DebugComponent.CustomDebugInfoSource("reverse-search-debug", info)); } @@ -154,19 +150,19 @@ private static DocumentBatchVisitor documentBatchVisitor( if (!(jsonParams instanceof Map)) { throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "need params"); } - var paramMap = (Map) jsonParams; - var documents = paramMap.get(MONITOR_DOCUMENTS_KEY); + Map paramMap = (Map) jsonParams; + Object documents = paramMap.get(MONITOR_DOCUMENTS_KEY); if (!(documents instanceof List)) { throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "need documents list"); } List luceneDocs = new ArrayList<>(); - for (var document : (List) documents) { + 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"); } - var docAsMap = (Map) document; + Map docAsMap = (Map) document; docAsMap.putIfAbsent(indexSchema.getUniqueKeyField().getName(), UUID.randomUUID().toString()); var solrInputDoc = JsonLoader.buildDoc((Map) document); var luceneDoc = DocumentBuilder.toDocument(solrInputDoc, indexSchema); diff --git a/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml b/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml index 661923bac3fa..9b3c7289aebb 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml @@ -88,16 +88,13 @@ + - - diff --git a/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml b/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml index 16e4a07eafd7..734afc91a882 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml @@ -91,10 +91,7 @@ useDocValuesAsStored="true"/> - - \ No newline at end of file diff --git a/solr/modules/monitor/src/test-files/solr/collection1/schema.xml b/solr/modules/monitor/src/test-files/solr/collection1/schema.xml index 390ffceb53f9..0aae08b7c014 100644 --- a/solr/modules/monitor/src/test-files/solr/collection1/schema.xml +++ b/solr/modules/monitor/src/test-files/solr/collection1/schema.xml @@ -91,12 +91,8 @@ useDocValuesAsStored="true"/> - - \ No newline at end of file From 882cda9f6f353e386387a2f26b02f5d477f1a9b5 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Sun, 1 Dec 2024 20:02:14 -0500 Subject: [PATCH 64/85] pull latest CandidateMatcher --- .../src/java/org/apache/lucene/monitor/CandidateMatcher.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/CandidateMatcher.java b/solr/modules/monitor/src/java/org/apache/lucene/monitor/CandidateMatcher.java index 9bd920bbdbd0..055f1b07c87c 100644 --- a/solr/modules/monitor/src/java/org/apache/lucene/monitor/CandidateMatcher.java +++ b/solr/modules/monitor/src/java/org/apache/lucene/monitor/CandidateMatcher.java @@ -95,7 +95,7 @@ protected final void addMatch(T match, int doc) { public abstract T resolve(T match1, T match2); /** Called by the Monitor if running a query throws an Exception */ - void reportError(String queryId, Exception e) { + public void reportError(String queryId, Exception e) { this.errors.put(queryId, e); } From 7c80daea7a4ecdc67f98cdda1a74ebe7955bf800 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Sun, 1 Dec 2024 22:18:57 -0500 Subject: [PATCH 65/85] monitor -> saved-search --- settings.gradle | 2 +- .../{monitor => saved-search}/build.gradle | 0 .../lucene/monitor/CandidateMatcher.java | 0 .../lucene/monitor/DocumentBatchVisitor.java | 0 .../apache/lucene/monitor/MonitorFields.java | 0 .../org/apache/lucene/monitor/QCEVisitor.java | 0 .../monitor/QueryTermFilterVisitor.java | 0 ...asingMultipassTermFilteredPresearcher.java | 0 .../solr/monitor/AliasingPresearcher.java | 0 .../AliasingTermFilteredPresearcher.java | 0 .../solr/monitor/MonitorDataValues.java | 0 .../solr/monitor/MonitorSchemaFields.java | 0 .../solr/monitor/SimpleQueryParser.java | 0 .../solr/monitor/SolrMonitorQueryDecoder.java | 0 .../solr/monitor/cache/MonitorQueryCache.java | 0 .../monitor/cache/SharedMonitorCache.java | 0 .../SharedMonitorCacheLatestRegenerator.java | 0 .../cache/VersionedQueryCacheEntry.java | 0 .../solr/monitor/cache/package-info.java | 0 .../org/apache/solr/monitor/package-info.java | 0 .../monitor/search/PresearcherFactory.java | 0 .../search/ReverseSearchComponent.java | 0 .../monitor/search/ReverseSearchHandler.java | 0 .../monitor/search/ReverseSearchQuery.java | 0 .../solr/monitor/search/SolrMatcherSink.java | 0 .../monitor/search/SyncSolrMatcherSink.java | 0 .../solr/monitor/search/package-info.java | 0 .../update/MonitorUpdateProcessorFactory.java | 0 .../update/MonitorUpdateRequestProcessor.java | 0 .../solr/monitor/update/package-info.java | 0 .../monitor/BigDisjunctionQuery.xml | 0 .../dangling-test-single-doc-batch.json | 0 .../src/test-files/monitor/doc0.json | 0 .../src/test-files/monitor/doc1.json | 0 .../src/test-files/monitor/doc2.json | 0 .../src/test-files/monitor/elevator-doc.json | 0 .../test-files/monitor/multi-value-doc.json | 0 .../solr/collection1/core.properties | 0 .../solr/collection1/schema-aliasing.xml | 0 .../solr/collection1/schema-stored-mq.xml | 0 .../test-files/solr/collection1/schema.xml | 0 .../solr/collection1/solrconfig-no-cache.xml | 0 .../collection1/solrconfig-single-core.xml | 0 .../solr/collection1/solrconfig.xml | 0 .../src/test-files/solr/solr.xml | 0 .../solr/monitor/MonitorSolrQueryTest.java | 0 .../monitor/NoCacheMonitorSolrQueryTest.java | 0 .../monitor/SingleCoreMonitorSolrTest.java | 0 .../monitor/StoredMonitorSolrQueryTest.java | 0 versions.lock | 13072 ++++++++-------- 50 files changed, 6537 insertions(+), 6537 deletions(-) rename solr/modules/{monitor => saved-search}/build.gradle (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/lucene/monitor/CandidateMatcher.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/lucene/monitor/DocumentBatchVisitor.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/lucene/monitor/MonitorFields.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/lucene/monitor/QCEVisitor.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/lucene/monitor/QueryTermFilterVisitor.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/AliasingMultipassTermFilteredPresearcher.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/AliasingPresearcher.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/AliasingTermFilteredPresearcher.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/MonitorDataValues.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/MonitorSchemaFields.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/SimpleQueryParser.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/cache/VersionedQueryCacheEntry.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/cache/package-info.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/package-info.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/search/PresearcherFactory.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/search/package-info.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java (100%) rename solr/modules/{monitor => saved-search}/src/java/org/apache/solr/monitor/update/package-info.java (100%) rename solr/modules/{monitor => saved-search}/src/test-files/monitor/BigDisjunctionQuery.xml (100%) rename solr/modules/{monitor => saved-search}/src/test-files/monitor/dangling-test-single-doc-batch.json (100%) rename solr/modules/{monitor => saved-search}/src/test-files/monitor/doc0.json (100%) rename solr/modules/{monitor => saved-search}/src/test-files/monitor/doc1.json (100%) rename solr/modules/{monitor => saved-search}/src/test-files/monitor/doc2.json (100%) rename solr/modules/{monitor => saved-search}/src/test-files/monitor/elevator-doc.json (100%) rename solr/modules/{monitor => saved-search}/src/test-files/monitor/multi-value-doc.json (100%) rename solr/modules/{monitor => saved-search}/src/test-files/solr/collection1/core.properties (100%) rename solr/modules/{monitor => saved-search}/src/test-files/solr/collection1/schema-aliasing.xml (100%) rename solr/modules/{monitor => saved-search}/src/test-files/solr/collection1/schema-stored-mq.xml (100%) rename solr/modules/{monitor => saved-search}/src/test-files/solr/collection1/schema.xml (100%) rename solr/modules/{monitor => saved-search}/src/test-files/solr/collection1/solrconfig-no-cache.xml (100%) rename solr/modules/{monitor => saved-search}/src/test-files/solr/collection1/solrconfig-single-core.xml (100%) rename solr/modules/{monitor => saved-search}/src/test-files/solr/collection1/solrconfig.xml (100%) rename solr/modules/{monitor => saved-search}/src/test-files/solr/solr.xml (100%) rename solr/modules/{monitor => saved-search}/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java (100%) rename solr/modules/{monitor => saved-search}/src/test/org/apache/solr/monitor/NoCacheMonitorSolrQueryTest.java (100%) rename solr/modules/{monitor => saved-search}/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java (100%) rename solr/modules/{monitor => saved-search}/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java (100%) diff --git a/settings.gradle b/settings.gradle index 6693d18a27ac..e9344553b6b4 100644 --- a/settings.gradle +++ b/settings.gradle @@ -56,7 +56,7 @@ include "solr:modules:ltr" include "solr:modules:s3-repository" include "solr:modules:scripting" include "solr:modules:sql" -include "solr:modules:monitor" +include "solr:modules:saved-search" include "solr:webapp" include "solr:benchmark" include "solr:test-framework" diff --git a/solr/modules/monitor/build.gradle b/solr/modules/saved-search/build.gradle similarity index 100% rename from solr/modules/monitor/build.gradle rename to solr/modules/saved-search/build.gradle diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/CandidateMatcher.java b/solr/modules/saved-search/src/java/org/apache/lucene/monitor/CandidateMatcher.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/lucene/monitor/CandidateMatcher.java rename to solr/modules/saved-search/src/java/org/apache/lucene/monitor/CandidateMatcher.java diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/DocumentBatchVisitor.java b/solr/modules/saved-search/src/java/org/apache/lucene/monitor/DocumentBatchVisitor.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/lucene/monitor/DocumentBatchVisitor.java rename to solr/modules/saved-search/src/java/org/apache/lucene/monitor/DocumentBatchVisitor.java diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java b/solr/modules/saved-search/src/java/org/apache/lucene/monitor/MonitorFields.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/lucene/monitor/MonitorFields.java rename to solr/modules/saved-search/src/java/org/apache/lucene/monitor/MonitorFields.java diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/QCEVisitor.java b/solr/modules/saved-search/src/java/org/apache/lucene/monitor/QCEVisitor.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/lucene/monitor/QCEVisitor.java rename to solr/modules/saved-search/src/java/org/apache/lucene/monitor/QCEVisitor.java diff --git a/solr/modules/monitor/src/java/org/apache/lucene/monitor/QueryTermFilterVisitor.java b/solr/modules/saved-search/src/java/org/apache/lucene/monitor/QueryTermFilterVisitor.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/lucene/monitor/QueryTermFilterVisitor.java rename to solr/modules/saved-search/src/java/org/apache/lucene/monitor/QueryTermFilterVisitor.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingMultipassTermFilteredPresearcher.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/AliasingMultipassTermFilteredPresearcher.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingMultipassTermFilteredPresearcher.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/AliasingMultipassTermFilteredPresearcher.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/AliasingPresearcher.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingPresearcher.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/AliasingPresearcher.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingTermFilteredPresearcher.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/AliasingTermFilteredPresearcher.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/AliasingTermFilteredPresearcher.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/AliasingTermFilteredPresearcher.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/MonitorDataValues.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorDataValues.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/MonitorDataValues.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorSchemaFields.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/MonitorSchemaFields.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/MonitorSchemaFields.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/MonitorSchemaFields.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/SimpleQueryParser.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/SimpleQueryParser.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/SimpleQueryParser.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/SimpleQueryParser.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/VersionedQueryCacheEntry.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/VersionedQueryCacheEntry.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/cache/VersionedQueryCacheEntry.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/VersionedQueryCacheEntry.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/cache/package-info.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/package-info.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/cache/package-info.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/package-info.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/package-info.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/package-info.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/package-info.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/package-info.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/PresearcherFactory.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/PresearcherFactory.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/search/PresearcherFactory.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/search/PresearcherFactory.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/search/package-info.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/package-info.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/search/package-info.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/search/package-info.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java diff --git a/solr/modules/monitor/src/java/org/apache/solr/monitor/update/package-info.java b/solr/modules/saved-search/src/java/org/apache/solr/monitor/update/package-info.java similarity index 100% rename from solr/modules/monitor/src/java/org/apache/solr/monitor/update/package-info.java rename to solr/modules/saved-search/src/java/org/apache/solr/monitor/update/package-info.java diff --git a/solr/modules/monitor/src/test-files/monitor/BigDisjunctionQuery.xml b/solr/modules/saved-search/src/test-files/monitor/BigDisjunctionQuery.xml similarity index 100% rename from solr/modules/monitor/src/test-files/monitor/BigDisjunctionQuery.xml rename to solr/modules/saved-search/src/test-files/monitor/BigDisjunctionQuery.xml diff --git a/solr/modules/monitor/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 similarity index 100% rename from solr/modules/monitor/src/test-files/monitor/dangling-test-single-doc-batch.json rename to solr/modules/saved-search/src/test-files/monitor/dangling-test-single-doc-batch.json diff --git a/solr/modules/monitor/src/test-files/monitor/doc0.json b/solr/modules/saved-search/src/test-files/monitor/doc0.json similarity index 100% rename from solr/modules/monitor/src/test-files/monitor/doc0.json rename to solr/modules/saved-search/src/test-files/monitor/doc0.json diff --git a/solr/modules/monitor/src/test-files/monitor/doc1.json b/solr/modules/saved-search/src/test-files/monitor/doc1.json similarity index 100% rename from solr/modules/monitor/src/test-files/monitor/doc1.json rename to solr/modules/saved-search/src/test-files/monitor/doc1.json diff --git a/solr/modules/monitor/src/test-files/monitor/doc2.json b/solr/modules/saved-search/src/test-files/monitor/doc2.json similarity index 100% rename from solr/modules/monitor/src/test-files/monitor/doc2.json rename to solr/modules/saved-search/src/test-files/monitor/doc2.json diff --git a/solr/modules/monitor/src/test-files/monitor/elevator-doc.json b/solr/modules/saved-search/src/test-files/monitor/elevator-doc.json similarity index 100% rename from solr/modules/monitor/src/test-files/monitor/elevator-doc.json rename to solr/modules/saved-search/src/test-files/monitor/elevator-doc.json diff --git a/solr/modules/monitor/src/test-files/monitor/multi-value-doc.json b/solr/modules/saved-search/src/test-files/monitor/multi-value-doc.json similarity index 100% rename from solr/modules/monitor/src/test-files/monitor/multi-value-doc.json rename to solr/modules/saved-search/src/test-files/monitor/multi-value-doc.json diff --git a/solr/modules/monitor/src/test-files/solr/collection1/core.properties b/solr/modules/saved-search/src/test-files/solr/collection1/core.properties similarity index 100% rename from solr/modules/monitor/src/test-files/solr/collection1/core.properties rename to solr/modules/saved-search/src/test-files/solr/collection1/core.properties diff --git a/solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml b/solr/modules/saved-search/src/test-files/solr/collection1/schema-aliasing.xml similarity index 100% rename from solr/modules/monitor/src/test-files/solr/collection1/schema-aliasing.xml rename to solr/modules/saved-search/src/test-files/solr/collection1/schema-aliasing.xml diff --git a/solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml b/solr/modules/saved-search/src/test-files/solr/collection1/schema-stored-mq.xml similarity index 100% rename from solr/modules/monitor/src/test-files/solr/collection1/schema-stored-mq.xml rename to solr/modules/saved-search/src/test-files/solr/collection1/schema-stored-mq.xml diff --git a/solr/modules/monitor/src/test-files/solr/collection1/schema.xml b/solr/modules/saved-search/src/test-files/solr/collection1/schema.xml similarity index 100% rename from solr/modules/monitor/src/test-files/solr/collection1/schema.xml rename to solr/modules/saved-search/src/test-files/solr/collection1/schema.xml diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml b/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig-no-cache.xml similarity index 100% rename from solr/modules/monitor/src/test-files/solr/collection1/solrconfig-no-cache.xml rename to solr/modules/saved-search/src/test-files/solr/collection1/solrconfig-no-cache.xml diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig-single-core.xml b/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig-single-core.xml similarity index 100% rename from solr/modules/monitor/src/test-files/solr/collection1/solrconfig-single-core.xml rename to solr/modules/saved-search/src/test-files/solr/collection1/solrconfig-single-core.xml diff --git a/solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml b/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig.xml similarity index 100% rename from solr/modules/monitor/src/test-files/solr/collection1/solrconfig.xml rename to solr/modules/saved-search/src/test-files/solr/collection1/solrconfig.xml diff --git a/solr/modules/monitor/src/test-files/solr/solr.xml b/solr/modules/saved-search/src/test-files/solr/solr.xml similarity index 100% rename from solr/modules/monitor/src/test-files/solr/solr.xml rename to solr/modules/saved-search/src/test-files/solr/solr.xml diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java b/solr/modules/saved-search/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java similarity index 100% rename from solr/modules/monitor/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java rename to solr/modules/saved-search/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/NoCacheMonitorSolrQueryTest.java b/solr/modules/saved-search/src/test/org/apache/solr/monitor/NoCacheMonitorSolrQueryTest.java similarity index 100% rename from solr/modules/monitor/src/test/org/apache/solr/monitor/NoCacheMonitorSolrQueryTest.java rename to solr/modules/saved-search/src/test/org/apache/solr/monitor/NoCacheMonitorSolrQueryTest.java diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java b/solr/modules/saved-search/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java similarity index 100% rename from solr/modules/monitor/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java rename to solr/modules/saved-search/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java diff --git a/solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java b/solr/modules/saved-search/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java similarity index 100% rename from solr/modules/monitor/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java rename to solr/modules/saved-search/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java diff --git a/versions.lock b/versions.lock index 0ad3c05be650..b6df8a9d6ec7 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" : "9fe1a5c8,refs=54", - "com.carrotsearch:hppc:0.10.0" : "cba6a444,refs=85", + "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" : "4dff1176,refs=103", - "com.fasterxml.jackson.core:jackson-core:2.18.0" : "6174b081,refs=104", - "com.fasterxml.jackson.core:jackson-databind:2.18.0" : "9a98b6bd,refs=100", - "com.fasterxml.jackson.dataformat:jackson-dataformat-cbor:2.18.0" : "3be32acc,refs=85", + "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" : "2b6e71e2,refs=83", + "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" : "2b6e71e2,refs=83", + "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" : "d05fa141,refs=108", - "com.fasterxml.woodstox:woodstox-core:7.0.0" : "fe67ba9c,refs=86", - "com.github.ben-manes.caffeine:caffeine:3.1.8" : "0bd4da9d,refs=118", + "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" : "21e8fe6d,refs=27", + "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" : "21e8fe6d,refs=27", - "com.google.auto.value:auto-value-annotations:1.10.4" : "64b385a8,refs=32", - "com.google.auto:auto-common:1.2.2" : "21e8fe6d,refs=27", + "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" : "21e8fe6d,refs=27", + "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" : "21e8fe6d,refs=27", - "com.google.errorprone:error_prone_annotations:2.31.0" : "d6325cd7,refs=156", - "com.google.errorprone:error_prone_check_api:2.31.0" : "21e8fe6d,refs=27", - "com.google.errorprone:error_prone_core:2.31.0" : "21e8fe6d,refs=27", - "com.google.errorprone:error_prone_type_annotations:2.31.0" : "21e8fe6d,refs=27", - "com.google.guava:failureaccess:1.0.2" : "d6325cd7,refs=156", - "com.google.guava:guava:33.1.0-jre" : "d6325cd7,refs=156", - "com.google.guava:listenablefuture:9999.0-empty-to-avoid-conflict-with-guava" : "d6325cd7,refs=156", + "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" : "a3bf4d96,refs=51", + "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" : "0530c27d,refs=49", + "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" : "2b6e71e2,refs=83", - "com.jayway.jsonpath:json-path:2.9.0" : "2b6e71e2,refs=83", - "com.lmax:disruptor:3.4.4" : "329bacb5,refs=28", + "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" : "2b6e71e2,refs=83", + "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" : "10138367,refs=91", - "commons-codec:commons-codec:1.17.1" : "9dad2dca,refs=111", + "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" : "cf578285,refs=130", + "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" : "2d083e51,refs=49", - "io.dropwizard.metrics:metrics-core:4.2.26" : "d045b497,refs=127", - "io.dropwizard.metrics:metrics-graphite:4.2.26" : "b9eea060,refs=85", + "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" : "2d083e51,refs=49", - "io.dropwizard.metrics:metrics-jmx:4.2.26" : "b9eea060,refs=85", + "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" : "31a7bc5e,refs=87", + "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" : "21e8fe6d,refs=27", - "io.github.java-diff-utils:java-diff-utils:4.12" : "21e8fe6d,refs=27", + "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" : "cf578285,refs=130", - "io.netty:netty-codec:4.1.114.Final" : "cf578285,refs=130", + "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" : "cf578285,refs=130", - "io.netty:netty-handler:4.1.114.Final" : "cf578285,refs=130", + "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" : "cf578285,refs=130", - "io.netty:netty-tcnative-boringssl-static:2.0.66.Final" : "cf578285,refs=130", - "io.netty:netty-tcnative-classes:2.0.66.Final" : "cf578285,refs=130", - "io.netty:netty-transport:4.1.114.Final" : "cf578285,refs=130", - "io.netty:netty-transport-classes-epoll:4.1.114.Final" : "cf578285,refs=130", - "io.netty:netty-transport-native-epoll:4.1.114.Final" : "cf578285,refs=130", - "io.netty:netty-transport-native-unix-common:4.1.114.Final" : "cf578285,refs=130", + "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" : "2c377a17,refs=125", + "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" : "2c377a17,refs=125", + "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" : "2b6e71e2,refs=83", - "io.prometheus:prometheus-metrics-model:1.1.0" : "2b6e71e2,refs=83", + "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" : "2b6e71e2,refs=83", - "io.swagger.core.v3:swagger-annotations-jakarta:2.2.22" : "adf8e1c0,refs=136", + "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" : "b6eb111e,refs=84", - "jakarta.inject:jakarta.inject-api:2.0.1" : "2b6e71e2,refs=83", + "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" : "2b6e71e2,refs=83", + "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" : "c549b7b1,refs=91", + "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" : "e2ba6832,refs=29", + "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" : "9fe1a5c8,refs=54", + "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" : "3d248c52,refs=81", + "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" : "9917a0a4,refs=85", - "org.apache.commons:commons-lang3:3.15.0" : "fc4f5282,refs=87", - "org.apache.commons:commons-math3:3.6.1" : "a55b8520,refs=91", + "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" : "d1868851,refs=129", - "org.apache.curator:curator-framework:5.7.1" : "d1868851,refs=129", + "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" : "74b255d2,refs=30", + "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" : "8199581b,refs=134", - "org.apache.httpcomponents:httpcore:4.4.16" : "8199581b,refs=134", - "org.apache.httpcomponents:httpmime:4.5.14" : "8199581b,refs=134", + "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,39 +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" : "f6b3fa6a,refs=21", - "org.apache.logging.log4j:log4j-api:2.21.0" : "4f65049f,refs=91", - "org.apache.logging.log4j:log4j-core:2.21.0" : "202a989d,refs=89", - "org.apache.logging.log4j:log4j-layout-template-json:2.21.0" : "4bc7278d,refs=20", - "org.apache.logging.log4j:log4j-slf4j2-impl:2.21.0" : "2814e751,refs=85", - "org.apache.logging.log4j:log4j-web:2.21.0" : "4bc7278d,refs=20", - "org.apache.lucene:lucene-analysis-common:9.11.1" : "2c377a17,refs=125", + "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" : "3d248c52,refs=81", + "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" : "3d248c52,refs=81", + "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" : "3d248c52,refs=81", + "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" : "2b6e71e2,refs=83", - "org.apache.lucene:lucene-classification:9.11.1" : "2b6e71e2,refs=83", - "org.apache.lucene:lucene-codecs:9.11.1" : "2b6e71e2,refs=83", - "org.apache.lucene:lucene-core:9.11.1" : "2c377a17,refs=125", - "org.apache.lucene:lucene-expressions:9.11.1" : "2b6e71e2,refs=83", - "org.apache.lucene:lucene-grouping:9.11.1" : "2b6e71e2,refs=83", - "org.apache.lucene:lucene-highlighter:9.11.1" : "2b6e71e2,refs=83", - "org.apache.lucene:lucene-join:9.11.1" : "2b6e71e2,refs=83", - "org.apache.lucene:lucene-memory:9.11.1" : "3d248c52,refs=81", - "org.apache.lucene:lucene-misc:9.11.1" : "2b6e71e2,refs=83", - "org.apache.lucene:lucene-monitor:9.11.1" : "286d3ac2,refs=5", - "org.apache.lucene:lucene-queries:9.11.1" : "2c377a17,refs=125", - "org.apache.lucene:lucene-queryparser:9.11.1" : "2b6e71e2,refs=83", - "org.apache.lucene:lucene-sandbox:9.11.1" : "2b6e71e2,refs=83", - "org.apache.lucene:lucene-spatial-extras:9.11.1" : "2b6e71e2,refs=83", - "org.apache.lucene:lucene-spatial3d:9.11.1" : "2b6e71e2,refs=83", - "org.apache.lucene:lucene-suggest:9.11.1" : "02377b26,refs=85", - "org.apache.lucene:lucene-test-framework:9.11.1" : "9fe1a5c8,refs=54", + "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", @@ -339,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" : "cf578285,refs=130", - "org.apache.zookeeper:zookeeper-jute:3.9.2" : "cf578285,refs=130", - "org.apiguardian:apiguardian-api:1.1.2" : "1a0f3663,refs=34", + "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", @@ -356,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" : "d6325cd7,refs=156", + "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" : "9917a0a4,refs=85", + "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" : "8199581b,refs=134", - "org.eclipse.jetty.http2:http2-common:10.0.22" : "4d22574d,refs=136", - "org.eclipse.jetty.http2:http2-hpack:10.0.22" : "4d22574d,refs=136", - "org.eclipse.jetty.http2:http2-http-client-transport:10.0.22" : "3708202c,refs=88", - "org.eclipse.jetty.http2:http2-server:10.0.22" : "f19e2720,refs=33", - "org.eclipse.jetty.toolchain:jetty-servlet-api:4.0.6" : "74dcd88a,refs=114", - "org.eclipse.jetty:jetty-alpn-client:10.0.22" : "8199581b,refs=134", - "org.eclipse.jetty:jetty-alpn-java-client:10.0.22" : "3708202c,refs=88", - "org.eclipse.jetty:jetty-alpn-java-server:10.0.22" : "1ad7b364,refs=31", - "org.eclipse.jetty:jetty-alpn-server:10.0.22" : "f19e2720,refs=33", - "org.eclipse.jetty:jetty-client:10.0.22" : "7f2093e0,refs=94", + "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" : "4d22574d,refs=136", - "org.eclipse.jetty:jetty-io:10.0.22" : "4d22574d,refs=136", + "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" : "f19e2720,refs=33", - "org.eclipse.jetty:jetty-security:10.0.22" : "7068fbcc,refs=61", - "org.eclipse.jetty:jetty-server:10.0.22" : "0e0be560,refs=112", - "org.eclipse.jetty:jetty-servlet:10.0.22" : "7068fbcc,refs=61", + "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" : "4d22574d,refs=136", + "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" : "2b6e71e2,refs=83", - "org.glassfish.hk2:hk2-api:3.1.1" : "2b6e71e2,refs=83", - "org.glassfish.hk2:hk2-locator:3.1.1" : "2b6e71e2,refs=83", - "org.glassfish.hk2:hk2-utils:3.1.1" : "2b6e71e2,refs=83", - "org.glassfish.hk2:osgi-resource-locator:1.0.3" : "2b6e71e2,refs=83", + "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" : "2b6e71e2,refs=83", - "org.glassfish.jersey.core:jersey-client:3.1.9" : "2b6e71e2,refs=83", - "org.glassfish.jersey.core:jersey-common:3.1.9" : "2b6e71e2,refs=83", - "org.glassfish.jersey.core:jersey-server:3.1.9" : "2b6e71e2,refs=83", - "org.glassfish.jersey.ext:jersey-entity-filtering:3.1.9" : "2b6e71e2,refs=83", - "org.glassfish.jersey.inject:jersey-hk2:3.1.9" : "2b6e71e2,refs=83", - "org.glassfish.jersey.media:jersey-media-json-jackson:3.1.9" : "2b6e71e2,refs=83", - "org.hamcrest:hamcrest:3.0" : "9fe1a5c8,refs=54", + "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" : "2b6e71e2,refs=83", + "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", @@ -416,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" : "21e8fe6d,refs=27", - "org.junit.jupiter:junit-jupiter-api:5.6.2" : "74b255d2,refs=30", - "org.junit.platform:junit-platform-commons:1.6.2" : "74b255d2,refs=30", - "org.junit:junit-bom:5.6.2" : "74b255d2,refs=30", + "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" : "2b6e71e2,refs=83", + "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", @@ -432,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" : "74b255d2,refs=30", + "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" : "6e47ac53,refs=84", - "org.ow2.asm:asm-analysis:7.2" : "3d248c52,refs=81", - "org.ow2.asm:asm-commons:7.2" : "3d248c52,refs=81", - "org.ow2.asm:asm-tree:7.2" : "3d248c52,refs=81", - "org.pcollections:pcollections:4.0.1" : "4e99a97b,refs=30", + "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", @@ -448,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" : "bd115d81,refs=89", - "org.slf4j:jcl-over-slf4j:2.0.13" : "eaeef440,refs=90", - "org.slf4j:jul-to-slf4j:2.0.13" : "bb22e93c,refs=27", - "org.slf4j:slf4j-api:2.0.13" : "b5a069d5,refs=138", + "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", @@ -476,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" : "b452c0f7,refs=86", + "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", @@ -525,7 +525,7 @@ "projectPath" : ":solr:modules:opentelemetry" } ], - "02377b26" : [ + "01b4f802" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -594,6 +594,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" @@ -606,18 +610,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" @@ -674,6 +670,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -686,6 +686,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -734,6 +738,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -788,51 +796,51 @@ }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -867,268 +875,292 @@ "projectPath" : ":solr:modules:sql" } ], - "0530c27d" : [ + "062c26b4" : [ { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:api" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:core" + "configuration" : "serverLib", + "projectPath" : ":solr:server" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, + "projectPath" : ":solr:modules:s3-repository" + } + ], + "067b0200" : [ { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "compileClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:server" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:test-framework" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:webapp" + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:clustering" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "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" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:langid" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:monitor" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:solrj" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "062c26b4" : [ - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:server" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:test-framework" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "serverLib", + "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "0769b123" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - } - ], - "0a82b27c" : [ + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "compileClasspath", @@ -1142,6 +1174,10 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:extraction" @@ -1163,666 +1199,776 @@ "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - } - ], - "0bd4da9d" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:api" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hdfs" + }, + { + "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" : "annotationProcessor", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "compileClasspath", + "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" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:server" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:test-framework" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:webapp" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "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" + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:clustering" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" }, { "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" + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" }, { "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:cross-dc" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "0769b123" : [ + { + "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" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:cross-dc-manager" + } + ], + "079d20a6" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:core" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:langid" + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "annotationProcessor", - "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" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "0d28f997" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - } - ], - "0e0be560" : [ + "projectPath" : ":solr:modules:jwt-auth" + }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "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" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:server" - }, + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "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:solr-ref-guide" + "projectPath" : ":solr:modules:sql" + } + ], + "0a82b27c" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "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:solrj-streaming" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "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:solrj-zookeeper" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + } + ], + "0bb51e54" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "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" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "solrCore", @@ -1840,10 +1986,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:analysis-extras" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -1860,10 +2002,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -1880,10 +2018,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -1900,10 +2034,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -1920,10 +2050,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -1940,10 +2066,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -1960,10 +2082,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -1980,10 +2098,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -2000,10 +2114,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:langid" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" @@ -2020,73 +2130,61 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -2100,10 +2198,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -2120,48 +2214,86 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "10138367" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - }, + "0d28f997" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, + "projectPath" : ":solr:modules:opentelemetry" + } + ], + "0e228a15" : [ + { + "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" + }, + { + "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" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -2174,6 +2306,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -2202,26 +2338,74 @@ "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" @@ -2242,10 +2426,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" @@ -2258,10 +2450,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" @@ -2274,10 +2474,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" @@ -2290,10 +2498,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" @@ -2306,10 +2522,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" @@ -2322,10 +2546,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" @@ -2338,6 +2570,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -2366,6 +2602,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -2378,10 +2618,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" @@ -2394,10 +2642,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" @@ -2411,24 +2667,16 @@ "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", @@ -2442,10 +2690,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" @@ -2458,384 +2714,598 @@ "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" - } - ], - "1643ad05" : [ + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "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" } ], - "1a0f3663" : [ + "0f014dd0" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" }, { - "configuration" : "runtimeClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:benchmark" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "compileClasspath", "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "serverLib", + "projectPath" : ":solr:server" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:solrj" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:test-framework" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:test-framework" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:test-framework" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "1ad7b364" : [ + "projectPath" : ":solr:test-framework" + }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "1e12e466" : [ + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "202a989d" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "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:benchmark" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "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" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", + "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" : "testCompileClasspath", + "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" : "testCompileClasspath", + "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" : "testCompileClasspath", + "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" : "testCompileClasspath", + "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" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "157928e7" : [ + { + "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:prometheus-exporter" @@ -2849,12 +3319,12 @@ "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", @@ -2896,10 +3366,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" - }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -3000,6 +3466,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -3012,6 +3482,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -3066,51 +3540,51 @@ }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -3145,239 +3619,97 @@ "projectPath" : ":solr:modules:sql" } ], - "20f1e0e0" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, + "1643ad05" : [ { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:hadoop-auth" } ], - "21e8fe6d" : [ + "1adb38f7" : [ { - "configuration" : "annotationProcessor", + "configuration" : "compileClasspath", "projectPath" : ":solr:api" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:core" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" }, { - "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" : "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:monitor" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" - } - ], - "23e8a2eb" : [ { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - } - ], - "24396a00" : [ - { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" - }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:server" - }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" - } - ], - "26b9da63" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - } - ], - "280cfec8" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - } - ], - "2814e751" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeLibs", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", + "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" @@ -3391,12 +3723,12 @@ "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", @@ -3410,14 +3742,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" @@ -3430,10 +3782,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" - }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -3486,6 +3834,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -3498,10 +3850,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" @@ -3514,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" @@ -3530,6 +3898,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -3550,6 +3922,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -3562,6 +3938,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -3600,51 +3980,55 @@ }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -3662,6 +4046,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -3674,38 +4062,28 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "286d3ac2" : [ + "1bda69a3" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:monitor" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" - } - ], - "2b6e71e2" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" @@ -3714,6 +4092,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:core" + }, { "configuration" : "compileClasspath", "projectPath" : ":solr:core" @@ -3734,6 +4116,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -3750,14 +4136,38 @@ "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" : "annotationProcessor", + "projectPath" : ":solr:server" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -3766,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" @@ -3790,10 +4220,18 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:webapp" + }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -3810,6 +4248,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -3826,6 +4268,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -3842,6 +4288,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -3858,6 +4308,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -3874,6 +4328,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -3890,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" @@ -3902,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" @@ -3922,6 +4396,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:langid" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:langid" @@ -3938,6 +4416,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:ltr" @@ -3954,53 +4436,77 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:opentelemetry" + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", @@ -4018,6 +4524,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -4035,25 +4545,77 @@ "projectPath" : ":solr:modules:sql" } ], - "2c377a17" : [ + "1e12e466" : [ { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, + "projectPath" : ":solr:modules:s3-repository" + } + ], + "20f1e0e0" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "23e8a2eb" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + } + ], + "24396a00" : [ + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:server" + }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + } + ], + "25903e1d" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, { @@ -4080,10 +4642,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -4097,19 +4655,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" }, { @@ -4117,43 +4675,31 @@ "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "runtimeClasspath", + "configuration" : "libExt", "projectPath" : ":solr:server" }, { - "configuration" : "solrCore", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { "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", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, { @@ -4173,12 +4719,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", @@ -4192,18 +4738,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" @@ -4216,18 +4754,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" @@ -4240,18 +4770,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" @@ -4264,18 +4786,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" @@ -4288,18 +4802,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" @@ -4312,18 +4818,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" @@ -4336,18 +4834,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" @@ -4360,18 +4850,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" @@ -4384,18 +4866,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" @@ -4408,89 +4882,57 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:monitor" - }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "compileClasspath", "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "compileClasspath", "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -4504,18 +4946,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" @@ -4528,74 +4962,162 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "2d06957b" : [ + "26b9da63" : [ { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" } ], - "2d083e51" : [ + "27d9a2c5" : [ + { + "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" + }, + { + "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: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" }, + { + "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" @@ -4617,1057 +5139,1041 @@ "projectPath" : ":solr:test-framework" }, { - "configuration" : "serverLib", + "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "31a7bc5e" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "280cfec8" : [ { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + } + ], + "28c7d4d7" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:api" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:core" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:core" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "libExt", + "projectPath" : ":solr:server" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "329bacb5" : [ + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "compileClasspath", + "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" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" - } - ], - "3708202c" : [ { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" }, { "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" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "2a08a891" : [ { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:core" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:core" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { "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" - } - ], - "3b210678" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "3be32acc" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:solrj-zookeeper" }, { "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" + "projectPath" : ":solr:test-framework" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" - }, - { - "configuration" : "solrCore", - "projectPath" : ":solr:server" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:test-framework" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, - { - "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" }, { @@ -5678,6 +6184,10 @@ "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -5690,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" @@ -5706,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" @@ -5722,10 +6248,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" @@ -5738,10 +6272,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" @@ -5754,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" @@ -5770,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" @@ -5786,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" @@ -5802,10 +6368,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" @@ -5818,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" @@ -5835,24 +6417,16 @@ "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", @@ -5866,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" @@ -5890,47 +6472,93 @@ "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" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "3d248c52" : [ + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "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" + } + ], + "2d06957b" : [ + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" + } + ], + "2d7a8cd1" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", @@ -5964,6 +6592,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" @@ -5972,6 +6608,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "libExt", + "projectPath" : ":solr:server" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -6004,6 +6644,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -6170,51 +6814,51 @@ }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -6249,632 +6893,672 @@ "projectPath" : ":solr:modules:sql" } ], - "4985a322" : [ + "30d41762" : [ { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - } - ], - "4bc7278d" : [ - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "projectPath" : ":solr:api" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:benchmark" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" - } - ], - "4bf37e93" : [ - { - "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" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - } - ], - "4d22574d" : [ + "projectPath" : ":solr:solrj-zookeeper" + }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" - }, - { - "configuration" : "serverLib", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:opentelemetry" }, { "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:clustering" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "370d61de" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "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" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "libExt", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "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" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "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" + }, + { + "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" : "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" : "testCompileClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" + "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:saved-search" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", @@ -6888,28 +7572,34 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "4dff1176" : [ + "3b210678" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:s3-repository" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "3c6dc5ac" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -6922,10 +7612,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -6934,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" @@ -6958,18 +7636,10 @@ "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" @@ -6982,10 +7652,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" @@ -7094,10 +7760,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -7110,10 +7772,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -7178,10 +7836,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -7220,55 +7874,51 @@ }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -7286,10 +7936,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -7302,31 +7948,35 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "4e99a97b" : [ + "428a31d2" : [ { - "configuration" : "annotationProcessor", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" }, { - "configuration" : "annotationProcessor", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, { - "configuration" : "annotationProcessor", + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", @@ -7336,172 +7986,22 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "testRuntimeClasspath", "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" : "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:monitor" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" - } - ], - "4f65049f" : [ - { - "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" - }, - { - "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" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, - { - "configuration" : "libExt", - "projectPath" : ":solr:server" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -7526,26 +8026,14 @@ "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" @@ -7598,10 +8086,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -7614,10 +8098,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -7720,51 +8200,51 @@ }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -7799,6 +8279,26 @@ "projectPath" : ":solr:modules:sql" } ], + "4985a322" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + } + ], + "4bf37e93" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + } + ], "4f81d786" : [ { "configuration" : "testCompileClasspath", @@ -7879,29 +8379,31 @@ "projectPath" : ":solr:benchmark" } ], - "5f4312f3" : [ + "5331c7d2" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - } - ], - "5f62bd8e" : [ + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:core" @@ -7911,174 +8413,32 @@ "projectPath" : ":solr:core" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:prometheus-exporter" }, { - "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" - } - ], - "5fc760f2" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" - } - ], - "5fcc0587" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - } - ], - "6174b081" : [ - { - "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" - }, - { - "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" - }, - { - "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: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" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { "configuration" : "solrCore", @@ -8088,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" @@ -8204,10 +8544,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -8220,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" @@ -8244,10 +8572,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -8280,10 +8604,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -8320,22 +8640,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -8372,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" @@ -8388,10 +8708,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -8404,215 +8720,79 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "64b385a8" : [ + "54caaa1f" : [ { - "configuration" : "annotationProcessor", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" }, { - "configuration" : "annotationProcessor", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "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" - }, - { - "configuration" : "runtimeLibs", - "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" : "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:monitor" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" - } - ], - "69bf1b73" : [ - { - "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" - } - ], - "6e47ac53" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "libExt", + "projectPath" : ":solr:server" }, { "configuration" : "runtimeClasspath", @@ -8638,14 +8818,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" @@ -8782,10 +8974,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -8824,51 +9012,51 @@ }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -8903,45 +9091,29 @@ "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" - } - ], - "7068fbcc" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, + "5f4312f3" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - }, + "projectPath" : ":solr:modules:hdfs" + } + ], + "5f62bd8e" : [ { "configuration" : "testCompileClasspath", "projectPath" : ":solr:core" @@ -8951,216 +9123,242 @@ "projectPath" : ":solr:core" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:solrj" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, - { + "projectPath" : ":solr:modules:s3-repository" + } + ], + "5fc760f2" : [ + { "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" - }, + "projectPath" : ":solr:core" + } + ], + "5fcc0587" : [ { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:opentelemetry" + } + ], + "69bf1b73" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:langid" + } + ], + "6ac2c5f8" : [ + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:core" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:server" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:monitor" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:sql" + } + ], + "6fb73f3a" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:gcs-repository" } ], "727aea63" : [ @@ -9193,7 +9391,7 @@ "projectPath" : ":solr:modules:sql" } ], - "74b255d2" : [ + "73ad51d3" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -9207,21 +9405,49 @@ "projectPath" : ":solr:benchmark" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeLibs", "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" @@ -9239,560 +9465,488 @@ "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" : "testRuntimeClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "74dcd88a" : [ + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hdfs" }, { "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" + "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" - }, - { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:opentelemetry" }, { "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:clustering" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, + "projectPath" : ":solr:modules:sql" + } + ], + "761c3c3c" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:core" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:hadoop-auth" - }, + } + ], + "762fd911" : [ { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:api" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "libExt", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:test-framework" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "761c3c3c" : [ + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" } ], "778d978f" : [ @@ -9829,453 +9983,393 @@ "projectPath" : ":solr:cross-dc-manager" } ], - "781655d3" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" - } - ], - "784a94ea" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, + "77b11a58" : [ { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "libExt", + "projectPath" : ":solr:server" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - } - ], - "7accccef" : [ { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "7df0e72e" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "7f2093e0" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + } + ], + "781655d3" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:opentelemetry" + } + ], + "784a94ea" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:gcs-repository" + } + ], + "79a684e6" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:core" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "serverLib", + "projectPath" : ":solr:server" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "runtimeLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, + "projectPath" : ":solr:modules:sql" + } + ], + "7accccef" : [ { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" - }, + "projectPath" : ":solr:modules:s3-repository" + } + ], + "7df0e72e" : [ { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "7ebc5830" : [ { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "libExt", + "projectPath" : ":solr:server" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" } ], - "8199581b" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" - }, + "84863960" : [ { "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" @@ -10300,10 +10394,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -10316,18 +10406,10 @@ "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" @@ -10341,11 +10423,7 @@ "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "testRuntimeClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, { @@ -10356,10 +10434,6 @@ "configuration" : "solrCore", "projectPath" : ":solr:server" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" @@ -10380,50 +10454,26 @@ "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" @@ -10432,10 +10482,6 @@ "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -10448,18 +10494,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" @@ -10472,18 +10510,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" @@ -10496,18 +10526,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" @@ -10520,18 +10542,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" @@ -10544,10 +10558,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -10576,10 +10586,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -10592,10 +10598,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -10624,10 +10626,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:langid" @@ -10640,18 +10638,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" @@ -10664,89 +10654,57 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:monitor" - }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "compileClasspath", "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "compileClasspath", "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -10760,18 +10718,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" @@ -10784,252 +10734,142 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "87cc13ff" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" - }, + "84b99a57" : [ { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:api" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "8ba2f0f7" : [ + "projectPath" : ":solr:api" + }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:benchmark" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:benchmark" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - } - ], - "8d0cef4c" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:benchmark" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:core" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:core" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "90aa62e6" : [ { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - } - ], - "934e1fc5" : [ - { - "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - } - ], - "93acde90" : [ + "projectPath" : ":solr:prometheus-exporter" + }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "970f2ee7" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" - } - ], - "9917a0a4" : [ - { - "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" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:solrj" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testCompileClasspath", + "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" }, { @@ -11040,6 +10880,10 @@ "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -11052,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" @@ -11068,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" @@ -11084,6 +10944,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -11112,6 +10976,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -11124,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" @@ -11140,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" @@ -11156,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" @@ -11172,10 +11064,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" @@ -11188,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" @@ -11204,57 +11112,89 @@ "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:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", @@ -11268,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" @@ -11284,12 +11232,16 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "9a98b6bd" : [ + "87874129" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -11302,18 +11254,6 @@ "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" @@ -11323,92 +11263,306 @@ "projectPath" : ":solr:core" }, { - "configuration" : "compileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "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" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "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" : "compileClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:modules:sql" + } + ], + "87cc13ff" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "8ba2f0f7" : [ + { + "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:jwt-auth" + } + ], + "8d0cef4c" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "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: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" + } + ], + "90aa62e6" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + } + ], + "90ad3802" : [ + { + "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" + }, + { + "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" : "testCompileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", @@ -11474,10 +11628,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -11490,10 +11640,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -11558,10 +11704,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -11600,55 +11742,55 @@ }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -11666,10 +11808,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -11682,16 +11820,12 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "9bcc8206" : [ + "934e1fc5" : [ { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -11700,46 +11834,66 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" + } + ], + "93acde90" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:sql" } ], - "9dad2dca" : [ + "970f2ee7" : [ { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, + "projectPath" : ":solr:solrj-streaming" + } + ], + "987aa92c" : [ { "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" }, { @@ -11766,6 +11920,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -11778,6 +11936,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -11834,18 +11996,10 @@ "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" @@ -11858,18 +12012,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" @@ -11910,10 +12056,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -11926,10 +12068,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -11958,10 +12096,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -11974,18 +12108,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" @@ -11998,10 +12124,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -12018,18 +12140,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" @@ -12084,59 +12198,55 @@ }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "compileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -12154,6 +12264,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -12166,282 +12280,270 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "9e97e18c" : [ + "98f116c7" : [ { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "annotationProcessor", "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:server" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "9fe1a5c8" : [ + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj" + }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" - }, + "projectPath" : ":solr:modules:sql" + } + ], + "9bcc8206" : [ { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" - }, + "projectPath" : ":solr:modules:jwt-auth" + } + ], + "9e7d4624" : [ { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:api" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "a3bf4d96" : [ - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:benchmark" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:core" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "compileClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:core" }, { @@ -12449,8 +12551,8 @@ "projectPath" : ":solr:core" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", @@ -12461,7 +12563,7 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, { @@ -12469,72 +12571,120 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:server" + }, + { + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "compileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "compileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { - "configuration" : "compileClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "compileClasspath", + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "compileClasspath", + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testCompileClasspath", + "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", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeClasspath", @@ -12545,7 +12695,7 @@ "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testCompileClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, { @@ -12553,587 +12703,331 @@ "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" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:monitor" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:monitor" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "a55b8520" : [ { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "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" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "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" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "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" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" - }, + "projectPath" : ":solr:modules:sql" + } + ], + "9e97e18c" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "a2e0112a" : [ { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:server" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "serverLib", + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:solrj" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "runtimeClasspath", + "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" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { - "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:monitor" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "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: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" - } - ], - "a5b348ef" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - } - ], - "a6a1e3c5" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "a7f96198" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testRuntimeClasspath", - "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:gcs-repository" - } - ], - "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" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - } - ], - "adf8e1c0" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:api" - }, + "a5a4778d" : [ { "configuration" : "testCompileClasspath", "projectPath" : ":solr:api" @@ -13230,6 +13124,10 @@ "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:server" + }, { "configuration" : "solrCore", "projectPath" : ":solr:server" @@ -13306,6 +13204,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -13552,75 +13454,75 @@ }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "compileClasspath", @@ -13671,19 +13573,125 @@ "projectPath" : ":solr:modules:sql" } ], - "b452c0f7" : [ + "a5b348ef" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + } + ], + "a6a1e3c5" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "a7f96198" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "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:gcs-repository" + } + ], + "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" @@ -13700,6 +13708,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -13712,6 +13724,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -13720,6 +13736,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" @@ -13728,22 +13748,42 @@ "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" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-streaming" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solrj-zookeeper" @@ -13764,6 +13804,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -13780,6 +13824,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -13796,6 +13844,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -13812,6 +13864,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -13828,6 +13884,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -13844,6 +13904,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -13861,12 +13925,12 @@ "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeClasspath", @@ -13900,6 +13964,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -13916,6 +13984,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:langid" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" @@ -13932,57 +14004,73 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -13996,6 +14084,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" @@ -14012,62 +14104,144 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "b4755bf3" : [ + "a9f15c33" : [ { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:core" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", + "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" : "testRuntimeClasspath", + "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" : "annotationProcessor", "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", + "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" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:sql" } ], - "b5a069d5" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:api" - }, + "aa7a59c6" : [ { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "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" @@ -14104,10 +14278,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -14120,74 +14290,30 @@ "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" @@ -14208,50 +14334,22 @@ "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" @@ -14264,18 +14362,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" @@ -14288,18 +14378,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" @@ -14312,10 +14394,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -14344,10 +14422,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -14360,18 +14434,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" @@ -14384,18 +14450,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" @@ -14408,18 +14466,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" @@ -14432,18 +14482,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" @@ -14456,18 +14498,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" @@ -14480,89 +14514,57 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:monitor" - }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "compileClasspath", "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "compileClasspath", "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -14576,18 +14578,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" @@ -14600,38 +14594,12 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, - { - "configuration" : "testCompileClasspath", - "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" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - } - ], - "b6eb111e" : [ + "abf04837" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -14664,6 +14632,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -14676,14 +14648,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" @@ -14700,14 +14692,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" @@ -14772,6 +14784,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -14784,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" @@ -14800,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" @@ -14816,6 +14848,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -14848,6 +14884,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -14884,22 +14924,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -14936,6 +14960,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" @@ -14952,6 +14992,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -14964,66 +15008,138 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "b6f115a3" : [ + "acc31ef6" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + } + ], + "afdb2998" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" + } + ], + "b4755bf3" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" } ], - "b9eea060" : [ + "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" @@ -15045,31 +15161,59 @@ "projectPath" : ":solr:core" }, { - "configuration" : "runtimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "annotationProcessor", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "libExt", + "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" }, { @@ -15080,38 +15224,98 @@ "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" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, { - "configuration" : "serverLib", + "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" @@ -15124,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" @@ -15140,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" @@ -15156,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" @@ -15172,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" @@ -15188,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" @@ -15204,10 +15468,22 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "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" @@ -15220,10 +15496,22 @@ "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" @@ -15236,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" @@ -15252,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" @@ -15269,24 +15581,20 @@ "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", @@ -15300,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" @@ -15316,172 +15636,182 @@ "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: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" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" + }, + { + "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" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "bb22e93c" : [ + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "b6a343e2" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + } + ], + "b6f115a3" : [ { - "configuration" : "testCompileClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:langid" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:langid" } ], - "bd115d81" : [ + "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" }, { @@ -15489,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", @@ -15513,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" }, { @@ -15537,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" }, { @@ -15553,7 +15883,7 @@ "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-streaming" }, { @@ -15561,7 +15891,7 @@ "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-zookeeper" }, { @@ -15569,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" }, { @@ -15597,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" }, { @@ -15613,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" }, { @@ -15629,15 +15943,7 @@ "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:extraction" }, { @@ -15645,15 +15951,7 @@ "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" }, { @@ -15661,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" }, { @@ -15677,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" }, { @@ -15693,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" }, { @@ -15709,79 +15983,31 @@ "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" }, { "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:monitor" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "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", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:s3-repository" }, { @@ -15789,15 +16015,15 @@ "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:scripting" }, { @@ -15805,15 +16031,7 @@ "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:sql" }, { @@ -15821,59 +16039,7 @@ "projectPath" : ":solr:modules:sql" } ], - "bf04d2b8" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "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" - } - ], - "c549b7b1" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:api" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" - }, + "b9b86677" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -15886,10 +16052,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -15922,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" @@ -15950,34 +16104,30 @@ "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", + "configuration" : "testRuntimeClasspath", "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" @@ -16082,6 +16232,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -16094,6 +16248,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -16148,51 +16306,51 @@ }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -16227,10 +16385,14 @@ "projectPath" : ":solr:modules:sql" } ], - "c6acb8a9" : [ + "baa40a7b" : [ { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "runtimeClasspath", @@ -16244,99 +16406,157 @@ "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" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - } - ], - "c718e885" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "libExt", + "projectPath" : ":solr:server" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:server" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - } - ], - "c77c5ec7" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - } - ], - "cba6a444" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "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" + } + ], + "bf04d2b8" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + } + ], + "bf5445e0" : [ + { + "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" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", @@ -16358,6 +16578,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "libExt", + "projectPath" : ":solr:server" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -16390,6 +16614,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -16410,10 +16638,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:clustering" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -16426,10 +16650,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -16564,51 +16784,51 @@ }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -16643,26 +16863,10 @@ "projectPath" : ":solr:modules:sql" } ], - "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" - }, + "c1e4e901" : [ { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeClasspath", @@ -16677,35 +16881,31 @@ "projectPath" : ":solr:modules:opentelemetry" } ], - "cf578285" : [ + "c2770301" : [ { - "configuration" : "testCompileClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:api" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:api" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -16714,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" @@ -16738,18 +16930,10 @@ "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" @@ -16762,10 +16946,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:prometheus-exporter" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" @@ -16778,16 +16958,12 @@ "configuration" : "solrCore", "projectPath" : ":solr:server" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:solrj" }, { @@ -16795,41 +16971,25 @@ "projectPath" : ":solr:solrj" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", "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" @@ -16838,10 +16998,6 @@ "configuration" : "solrCore", "projectPath" : ":solr:webapp" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -16854,18 +17010,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" @@ -16878,18 +17026,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" @@ -16902,18 +17042,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" @@ -16926,18 +17058,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" @@ -16950,18 +17074,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" @@ -16974,18 +17090,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" @@ -16998,18 +17106,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" @@ -17022,18 +17122,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" @@ -17046,18 +17138,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" @@ -17070,89 +17154,57 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:monitor" - }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "compileClasspath", "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "compileClasspath", "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -17167,46 +17219,76 @@ "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "compileClasspath", + "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:sql" }, { - "configuration" : "runtimeClasspath", + "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, { - "configuration" : "runtimeLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" + } + ], + "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:modules:sql" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "d045b497" : [ + "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:api" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:cross-dc" + } + ], + "c718e885" : [ + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" }, { "configuration" : "compileClasspath", @@ -17220,6 +17302,38 @@ "configuration" : "testCompileClasspath", "projectPath" : ":solr:benchmark" }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + } + ], + "c77c5ec7" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + } + ], + "caaf5d31" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" @@ -17244,10 +17358,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -17260,29 +17370,25 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:cross-dc-manager" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testCompileClasspath", + "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", @@ -17292,16 +17398,12 @@ "configuration" : "solrCore", "projectPath" : ":solr:server" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:solrj" }, { @@ -17309,7 +17411,7 @@ "projectPath" : ":solr:solrj" }, { - "configuration" : "testCompileClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:solrj-streaming" }, { @@ -17317,41 +17419,25 @@ "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" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:analysis-extras" @@ -17364,18 +17450,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" @@ -17388,18 +17466,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" @@ -17412,18 +17482,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" @@ -17436,18 +17498,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" @@ -17460,18 +17514,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" @@ -17484,18 +17530,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" @@ -17508,18 +17546,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" @@ -17532,18 +17562,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" @@ -17557,17 +17579,9 @@ "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:langid" }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:ltr" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:ltr" @@ -17580,89 +17594,57 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:monitor" - }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "compileClasspath", "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "compileClasspath", "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -17676,18 +17658,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" @@ -17700,28 +17674,46 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "d05fa141" : [ + "cef2dbfe" : [ { "configuration" : "compileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "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" + } + ], + "d10c49c4" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -17754,10 +17746,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -17770,34 +17758,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" @@ -17814,34 +17782,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" @@ -17874,6 +17822,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:analysis-extras" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -17886,6 +17838,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" @@ -17906,10 +17862,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:extraction" @@ -17922,18 +17874,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" @@ -17946,18 +17890,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" @@ -17970,10 +17906,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -17994,10 +17926,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -18010,10 +17938,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -18052,55 +17976,51 @@ }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -18118,10 +18038,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:sql" @@ -18134,1166 +18050,1042 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:sql" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:sql" } ], - "d1868851" : [ + "d3cf8553" : [ { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "libExt", + "projectPath" : ":solr:server" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:server" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "solrPlatformLibs", + "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" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" - }, + "projectPath" : ":solr:modules:sql" + } + ], + "d3d191b2" : [ { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "d6a20741" : [ { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:core" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:server" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" - }, - { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrCore", + "configuration" : "annotationProcessor", "projectPath" : ":solr:webapp" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "testCompileClasspath", + "configuration" : "annotationProcessor", "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" : "annotationProcessor", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" + } + ], + "da1b785b" : [ { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:api" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:api" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:benchmark" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:benchmark" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:benchmark" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:benchmark" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hdfs" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:core" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:core" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:server" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "solrCore", + "projectPath" : ":solr:server" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:solrj" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:solrj" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:solrj" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:solrj" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:test-framework" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:scripting" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:test-framework" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:test-framework" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:analysis-extras" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "d3d191b2" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:sql" - } - ], - "d6325cd7" : [ - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:api" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:benchmark" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:clustering" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:core" + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "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", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:cross-dc-manager" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:server" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:server" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solr-ref-guide" + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solr-ref-guide" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-streaming" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-streaming" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:test-framework" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:webapp" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:cross-dc" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "projectPath" : ":solr:modules:scripting" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hadoop-auth" + "projectPath" : ":solr:modules:scripting" }, { "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" + "projectPath" : ":solr:modules:sql" }, { "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" + } + ], + "dd724fae" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { "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" + } + ], + "debe9836" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "e2f3f42e" : [ { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:extraction" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "e5144e73" : [ { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" + "projectPath" : ":solr:api" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:langid" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:core" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:core" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:langid" + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:langid" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:core" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:cross-dc-manager" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:prometheus-exporter" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:server" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:solrj" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-streaming" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:scripting" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testRuntimeClasspath", + "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" : "testCompileClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:sql" + "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: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" - } - ], - "dd724fae" : [ + "projectPath" : ":solr:modules:extraction" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -19302,187 +19094,189 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:modules:gcs-repository" }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:gcs-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" - } - ], - "debe9836" : [ + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" - } - ], - "e2ba6832" : [ + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:api" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:benchmark" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:server" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solr-ref-guide" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-streaming" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:solrj-zookeeper" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:test-framework" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:webapp" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:clustering" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:extraction" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:hdfs" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:jwt-auth" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:langid" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:monitor" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "annotationProcessor", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "annotationProcessor", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "annotationProcessor", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:sql" - } - ], - "e2f3f42e" : [ + }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:sql" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:extraction" + "projectPath" : ":solr:modules:sql" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:sql" } ], "e6d93f27" : [ @@ -19563,65 +19357,33 @@ "projectPath" : ":solr:modules:sql" } ], - "e972cbed" : [ - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, + "e9094088" : [ { "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" + "projectPath" : ":solr:api" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hdfs" - } - ], - "e9990913" : [ - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" + "projectPath" : ":solr:api" }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:solrj" - }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:jwt-auth" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:jwt-auth" - } - ], - "eaeef440" : [ - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:api" + "projectPath" : ":solr:benchmark" }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:benchmark" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:core" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" }, { - "configuration" : "runtimeLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:core" }, { @@ -19629,15 +19391,7 @@ "projectPath" : ":solr:core" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:cross-dc-manager" }, { @@ -19645,15 +19399,7 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" - }, - { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:prometheus-exporter" }, { @@ -19661,23 +19407,15 @@ "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "libExt", - "projectPath" : ":solr:server" - }, - { - "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" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj" }, { @@ -19685,7 +19423,7 @@ "projectPath" : ":solr:solrj" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-streaming" }, { @@ -19693,7 +19431,7 @@ "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:solrj-zookeeper" }, { @@ -19701,31 +19439,23 @@ "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:test-framework" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeClasspath", "projectPath" : ":solr:test-framework" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" - }, - { - "configuration" : "solrCore", - "projectPath" : ":solr:webapp" - }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:analysis-extras" }, { @@ -19733,15 +19463,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" }, { @@ -19749,37 +19471,13 @@ "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" }, { "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", - "projectPath" : ":solr:modules:extraction" - }, { "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:extraction" @@ -19789,15 +19487,7 @@ "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" }, { @@ -19805,111 +19495,47 @@ "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" - }, - { - "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" : "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" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:ltr" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" + "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:langid" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:opentelemetry" }, { @@ -19917,219 +19543,233 @@ "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "runtimeLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { - "configuration" : "runtimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "runtimeLibs", + "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:scripting" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:scripting" - }, + "projectPath" : ":solr:modules:sql" + } + ], + "e972cbed" : [ { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:hadoop-auth" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:sql" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:sql" + "projectPath" : ":solr:modules:hdfs" } ], - "ef8aea8b" : [ + "e9990913" : [ { - "configuration" : "testRuntimeClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:core" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "compileClasspath", "projectPath" : ":solr:solrj" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - }, - { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:jwt-auth" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:ltr" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:jwt-auth" } ], - "f19e2720" : [ + "ecbbe36e" : [ { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:api" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:benchmark" - }, - { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:benchmark" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:core" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" - }, - { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" - }, - { - "configuration" : "serverLib", + "configuration" : "annotationProcessor", "projectPath" : ":solr:server" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:solrj" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:solrj-streaming" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "compileClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:test-framework" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:webapp" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:test-framework" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:extraction" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "runtimeLibs", + "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" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:langid" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "annotationProcessor", "projectPath" : ":solr:modules:sql" } ], - "f493e7bb" : [ + "ece6e856" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:cross-dc-manager" @@ -20139,7 +19779,7 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:cross-dc-manager" }, { @@ -20147,29 +19787,47 @@ "projectPath" : ":solr:cross-dc-manager" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:cross-dc" - } - ], - "f5acb352" : [ + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, { "configuration" : "compileClasspath", - "projectPath" : ":solr:modules:clustering" + "projectPath" : ":solr:solrj-zookeeper" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:clustering" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:clustering" }, { @@ -20177,129 +19835,153 @@ "projectPath" : ":solr:modules:clustering" }, { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:clustering" - } - ], - "f6b3fa6a" : [ - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:cross-dc-manager" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" }, { - "configuration" : "libExt", - "projectPath" : ":solr:server" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:server" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" }, { - "configuration" : "serverLib", - "projectPath" : ":solr:webapp" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:analysis-extras" + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:clustering" + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:cross-dc" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:extraction" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:gcs-repository" + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "testRuntimeClasspath", + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:hdfs" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:langid" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:opentelemetry" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:s3-repository" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:saved-search" + }, + { + "configuration" : "compileClasspath", "projectPath" : ":solr:modules:scripting" }, { - "configuration" : "solrPlatformLibs", + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testCompileClasspath", "projectPath" : ":solr:modules:sql" } ], - "f7508386" : [ + "ef8aea8b" : [ { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hadoop-auth" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:hadoop-auth" - } - ], - "fa7556ff" : [ + "projectPath" : ":solr:solrj" + }, { - "configuration" : "compileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" }, { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" }, { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" }, { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:prometheus-exporter" + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:prometheus-exporter" + "projectPath" : ":solr:modules:s3-repository" } ], - "fc4f5282" : [ + "f05499c0" : [ { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:api" @@ -20312,10 +19994,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:benchmark" }, - { - "configuration" : "compileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:core" @@ -20324,10 +20002,6 @@ "configuration" : "runtimeLibs", "projectPath" : ":solr:core" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:core" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:core" @@ -20348,6 +20022,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" @@ -20356,6 +20038,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:prometheus-exporter" }, + { + "configuration" : "libExt", + "projectPath" : ":solr:server" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:server" @@ -20369,17 +20055,25 @@ "projectPath" : ":solr:solr-ref-guide" }, { - "configuration" : "testCompileClasspath", + "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" @@ -20392,6 +20086,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:test-framework" }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, { "configuration" : "solrCore", "projectPath" : ":solr:webapp" @@ -20512,10 +20210,6 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hdfs" }, - { - "configuration" : "testCompileClasspath", - "projectPath" : ":solr:modules:hdfs" - }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hdfs" @@ -20570,51 +20264,51 @@ }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" + "projectPath" : ":solr:modules:opentelemetry" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:opentelemetry" + "projectPath" : ":solr:modules:s3-repository" }, { "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:s3-repository" + "projectPath" : ":solr:modules:saved-search" }, { "configuration" : "runtimeClasspath", @@ -20649,15 +20343,75 @@ "projectPath" : ":solr:modules:sql" } ], - "fe67ba9c" : [ + "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:modules:clustering" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + } + ], + "f725590a" : [ { "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" @@ -20698,10 +20452,26 @@ "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" @@ -20718,22 +20488,58 @@ "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" : "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" @@ -20774,6 +20580,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:clustering" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -20786,6 +20596,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:cross-dc" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:cross-dc" @@ -20814,6 +20628,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:extraction" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:gcs-repository" @@ -20826,10 +20644,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" @@ -20842,6 +20668,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:hadoop-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:hadoop-auth" @@ -20858,10 +20688,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" @@ -20874,6 +20712,10 @@ "configuration" : "solrPlatformLibs", "projectPath" : ":solr:modules:jwt-auth" }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, { "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:jwt-auth" @@ -20910,22 +20752,6 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:ltr" }, - { - "configuration" : "runtimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "runtimeLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "solrPlatformLibs", - "projectPath" : ":solr:modules:monitor" - }, - { - "configuration" : "testRuntimeClasspath", - "projectPath" : ":solr:modules:monitor" - }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:opentelemetry" @@ -20942,6 +20768,10 @@ "configuration" : "testRuntimeClasspath", "projectPath" : ":solr:modules:opentelemetry" }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, { "configuration" : "runtimeClasspath", "projectPath" : ":solr:modules:s3-repository" @@ -20962,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" @@ -20994,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 From d869b3325a0ed667eb848fdd08aa3194e7a16bf6 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Wed, 4 Dec 2024 16:50:46 -0500 Subject: [PATCH 66/85] monitor -> savedsearch package --- .../AliasingMultipassTermFilteredPresearcher.java | 4 ++-- .../AliasingPresearcher.java | 2 +- .../AliasingTermFilteredPresearcher.java | 2 +- .../{monitor => savedsearch}/MonitorDataValues.java | 2 +- .../MonitorSchemaFields.java | 2 +- .../{monitor => savedsearch}/SimpleQueryParser.java | 2 +- .../SolrMonitorQueryDecoder.java | 4 ++-- .../cache/MonitorQueryCache.java | 6 +++--- .../cache/SharedMonitorCache.java | 6 +++--- .../cache/SharedMonitorCacheLatestRegenerator.java | 6 +++--- .../cache/VersionedQueryCacheEntry.java | 2 +- .../{monitor => savedsearch}/cache/package-info.java | 2 +- .../solr/{monitor => savedsearch}/package-info.java | 2 +- .../search/PresearcherFactory.java | 6 +++--- .../search/ReverseSearchComponent.java | 12 ++++++------ .../search/ReverseSearchHandler.java | 2 +- .../search/ReverseSearchQuery.java | 8 ++++---- .../search/SolrMatcherSink.java | 2 +- .../search/SyncSolrMatcherSink.java | 2 +- .../search/package-info.java | 2 +- .../update/MonitorUpdateProcessorFactory.java | 4 ++-- .../update/MonitorUpdateRequestProcessor.java | 6 +++--- .../update/package-info.java | 2 +- .../solr/collection1/solrconfig-no-cache.xml | 6 +++--- .../solr/collection1/solrconfig-single-core.xml | 10 +++++----- .../src/test-files/solr/collection1/solrconfig.xml | 10 +++++----- .../MonitorSolrQueryTest.java | 2 +- .../NoCacheMonitorSolrQueryTest.java | 2 +- .../SingleCoreMonitorSolrTest.java | 2 +- .../StoredMonitorSolrQueryTest.java | 2 +- 30 files changed, 61 insertions(+), 61 deletions(-) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/AliasingMultipassTermFilteredPresearcher.java (93%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/AliasingPresearcher.java (98%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/AliasingTermFilteredPresearcher.java (98%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/MonitorDataValues.java (98%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/MonitorSchemaFields.java (97%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/SimpleQueryParser.java (99%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/SolrMonitorQueryDecoder.java (95%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/cache/MonitorQueryCache.java (87%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/cache/SharedMonitorCache.java (98%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/cache/SharedMonitorCacheLatestRegenerator.java (95%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/cache/VersionedQueryCacheEntry.java (96%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/cache/package-info.java (95%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/package-info.java (96%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/search/PresearcherFactory.java (96%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/search/ReverseSearchComponent.java (96%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/search/ReverseSearchHandler.java (96%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/search/ReverseSearchQuery.java (97%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/search/SolrMatcherSink.java (96%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/search/SyncSolrMatcherSink.java (98%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/search/package-info.java (95%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/update/MonitorUpdateProcessorFactory.java (94%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/update/MonitorUpdateRequestProcessor.java (98%) rename solr/modules/saved-search/src/java/org/apache/solr/{monitor => savedsearch}/update/package-info.java (95%) rename solr/modules/saved-search/src/test/org/apache/solr/{monitor => savedsearch}/MonitorSolrQueryTest.java (99%) rename solr/modules/saved-search/src/test/org/apache/solr/{monitor => savedsearch}/NoCacheMonitorSolrQueryTest.java (96%) rename solr/modules/saved-search/src/test/org/apache/solr/{monitor => savedsearch}/SingleCoreMonitorSolrTest.java (99%) rename solr/modules/saved-search/src/test/org/apache/solr/{monitor => savedsearch}/StoredMonitorSolrQueryTest.java (97%) diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/AliasingMultipassTermFilteredPresearcher.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingMultipassTermFilteredPresearcher.java similarity index 93% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/AliasingMultipassTermFilteredPresearcher.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingMultipassTermFilteredPresearcher.java index ebf0dc1726e0..d3702033eca5 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/AliasingMultipassTermFilteredPresearcher.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingMultipassTermFilteredPresearcher.java @@ -17,9 +17,9 @@ * */ -package org.apache.solr.monitor; +package org.apache.solr.savedsearch; -import static org.apache.solr.monitor.AliasingTermFilteredPresearcher.AliasingDocumentQueryBuilder; +import static org.apache.solr.savedsearch.AliasingTermFilteredPresearcher.AliasingDocumentQueryBuilder; import java.util.List; import java.util.Set; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/AliasingPresearcher.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingPresearcher.java similarity index 98% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/AliasingPresearcher.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingPresearcher.java index fe9d047b8b68..9d1ea18e2e28 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/AliasingPresearcher.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingPresearcher.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor; +package org.apache.solr.savedsearch; import java.util.Map; import java.util.function.BiPredicate; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/AliasingTermFilteredPresearcher.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingTermFilteredPresearcher.java similarity index 98% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/AliasingTermFilteredPresearcher.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingTermFilteredPresearcher.java index 92b879e436d7..535eb2aed989 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/AliasingTermFilteredPresearcher.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingTermFilteredPresearcher.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor; +package org.apache.solr.savedsearch; import java.io.IOException; import java.util.List; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/MonitorDataValues.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/MonitorDataValues.java similarity index 98% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/MonitorDataValues.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/MonitorDataValues.java index 7dcfd3ae226b..d24975219f25 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/MonitorDataValues.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/MonitorDataValues.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor; +package org.apache.solr.savedsearch; import java.io.IOException; import org.apache.lucene.index.LeafReader; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/MonitorSchemaFields.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/MonitorSchemaFields.java similarity index 97% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/MonitorSchemaFields.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/MonitorSchemaFields.java index 9807f114e16e..4b8e6cd222be 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/MonitorSchemaFields.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/MonitorSchemaFields.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor; +package org.apache.solr.savedsearch; import org.apache.lucene.monitor.MonitorFields; import org.apache.solr.schema.IndexSchema; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/SimpleQueryParser.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SimpleQueryParser.java similarity index 99% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/SimpleQueryParser.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SimpleQueryParser.java index 69bd70d5a16b..2d7d41626b52 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/SimpleQueryParser.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SimpleQueryParser.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor; +package org.apache.solr.savedsearch; import java.security.Principal; import java.util.HashMap; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SolrMonitorQueryDecoder.java similarity index 95% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SolrMonitorQueryDecoder.java index 7f6b99f97ede..edf3f4a452c9 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/SolrMonitorQueryDecoder.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SolrMonitorQueryDecoder.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor; +package org.apache.solr.savedsearch; import java.io.IOException; import java.util.Map; @@ -25,7 +25,7 @@ import org.apache.lucene.monitor.QCEVisitor; import org.apache.lucene.monitor.QueryDecomposer; import org.apache.solr.core.SolrCore; -import org.apache.solr.monitor.search.ReverseSearchComponent; +import org.apache.solr.savedsearch.search.ReverseSearchComponent; public class SolrMonitorQueryDecoder { diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/MonitorQueryCache.java similarity index 87% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/MonitorQueryCache.java index a35f25632126..d571843756a9 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/MonitorQueryCache.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/MonitorQueryCache.java @@ -17,12 +17,12 @@ * */ -package org.apache.solr.monitor.cache; +package org.apache.solr.savedsearch.cache; import java.io.IOException; import org.apache.lucene.util.BytesRef; -import org.apache.solr.monitor.MonitorDataValues; -import org.apache.solr.monitor.SolrMonitorQueryDecoder; +import org.apache.solr.savedsearch.MonitorDataValues; +import org.apache.solr.savedsearch.SolrMonitorQueryDecoder; public interface MonitorQueryCache { diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SharedMonitorCache.java similarity index 98% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SharedMonitorCache.java index f010b8dfa548..9ff0bad302df 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/SharedMonitorCache.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SharedMonitorCache.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor.cache; +package org.apache.solr.savedsearch.cache; import static java.util.concurrent.TimeUnit.NANOSECONDS; @@ -38,8 +38,8 @@ import org.apache.solr.common.SolrException.ErrorCode; import org.apache.solr.metrics.MetricsMap; import org.apache.solr.metrics.SolrMetricsContext; -import org.apache.solr.monitor.MonitorDataValues; -import org.apache.solr.monitor.SolrMonitorQueryDecoder; +import org.apache.solr.savedsearch.MonitorDataValues; +import org.apache.solr.savedsearch.SolrMonitorQueryDecoder; import org.apache.solr.search.CacheRegenerator; import org.apache.solr.search.SolrCache; import org.apache.solr.search.SolrCacheBase; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SharedMonitorCacheLatestRegenerator.java similarity index 95% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SharedMonitorCacheLatestRegenerator.java index 689558df3cfe..732dae3c5c43 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/SharedMonitorCacheLatestRegenerator.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SharedMonitorCacheLatestRegenerator.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor.cache; +package org.apache.solr.savedsearch.cache; import java.io.IOException; import org.apache.lucene.document.LongPoint; @@ -25,8 +25,8 @@ import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; import org.apache.solr.common.params.CommonParams; -import org.apache.solr.monitor.MonitorDataValues; -import org.apache.solr.monitor.SolrMonitorQueryDecoder; +import org.apache.solr.savedsearch.MonitorDataValues; +import org.apache.solr.savedsearch.SolrMonitorQueryDecoder; import org.apache.solr.search.CacheRegenerator; import org.apache.solr.search.SolrCache; import org.apache.solr.search.SolrIndexSearcher; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/VersionedQueryCacheEntry.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/VersionedQueryCacheEntry.java similarity index 96% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/VersionedQueryCacheEntry.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/VersionedQueryCacheEntry.java index df74ed208069..bd55c998c95b 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/VersionedQueryCacheEntry.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/VersionedQueryCacheEntry.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor.cache; +package org.apache.solr.savedsearch.cache; import org.apache.lucene.monitor.QCEVisitor; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/package-info.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/package-info.java similarity index 95% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/package-info.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/package-info.java index 047ad946acdf..a9afe9f75386 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/cache/package-info.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/package-info.java @@ -18,4 +18,4 @@ */ /** This package contains caching logic for Solr's lucene-monitor integration. */ -package org.apache.solr.monitor.cache; +package org.apache.solr.savedsearch.cache; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/package-info.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/package-info.java similarity index 96% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/package-info.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/package-info.java index 7c825386a327..77d399ca08db 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/package-info.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/package-info.java @@ -18,4 +18,4 @@ */ /** This package contains Solr's lucene monitor integration. */ -package org.apache.solr.monitor; +package org.apache.solr.savedsearch; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/PresearcherFactory.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/PresearcherFactory.java similarity index 96% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/search/PresearcherFactory.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/PresearcherFactory.java index dced3f1cc61d..9a8cc275afbb 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/PresearcherFactory.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/PresearcherFactory.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor.search; +package org.apache.solr.savedsearch.search; import java.lang.reflect.Constructor; import java.util.List; @@ -28,8 +28,8 @@ import org.apache.lucene.monitor.TermFilteredPresearcher; import org.apache.lucene.monitor.TermWeightor; import org.apache.lucene.util.ResourceLoader; -import org.apache.solr.monitor.AliasingMultipassTermFilteredPresearcher; -import org.apache.solr.monitor.AliasingTermFilteredPresearcher; +import org.apache.solr.savedsearch.AliasingMultipassTermFilteredPresearcher; +import org.apache.solr.savedsearch.AliasingTermFilteredPresearcher; public class PresearcherFactory { diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchComponent.java similarity index 96% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchComponent.java index 4687b0162c28..dc175605e5db 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/ReverseSearchComponent.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchComponent.java @@ -17,9 +17,9 @@ * */ -package org.apache.solr.monitor.search; +package org.apache.solr.savedsearch.search; -import static org.apache.solr.monitor.search.PresearcherFactory.DEFAULT_ALIAS_PREFIX; +import static org.apache.solr.savedsearch.search.PresearcherFactory.DEFAULT_ALIAS_PREFIX; import java.io.IOException; import java.util.ArrayList; @@ -48,10 +48,10 @@ 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.monitor.AliasingPresearcher; -import org.apache.solr.monitor.SolrMonitorQueryDecoder; -import org.apache.solr.monitor.cache.MonitorQueryCache; -import org.apache.solr.monitor.cache.SharedMonitorCache; +import org.apache.solr.savedsearch.AliasingPresearcher; +import org.apache.solr.savedsearch.SolrMonitorQueryDecoder; +import org.apache.solr.savedsearch.cache.MonitorQueryCache; +import org.apache.solr.savedsearch.cache.SharedMonitorCache; import org.apache.solr.schema.IndexSchema; import org.apache.solr.schema.SchemaField; import org.apache.solr.update.DocumentBuilder; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchHandler.java similarity index 96% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchHandler.java index 951a67845873..1b6186ec3d9d 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/ReverseSearchHandler.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchHandler.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor.search; +package org.apache.solr.savedsearch.search; import java.util.ArrayList; import java.util.List; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchQuery.java similarity index 97% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchQuery.java index 9120c8170c11..cc73b1b4e219 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/ReverseSearchQuery.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchQuery.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor.search; +package org.apache.solr.savedsearch.search; import java.io.IOException; import java.util.Collection; @@ -36,9 +36,9 @@ import org.apache.lucene.search.ScorerSupplier; import org.apache.lucene.search.TwoPhaseIterator; import org.apache.lucene.search.Weight; -import org.apache.solr.monitor.MonitorDataValues; -import org.apache.solr.monitor.SolrMonitorQueryDecoder; -import org.apache.solr.monitor.cache.MonitorQueryCache; +import org.apache.solr.savedsearch.MonitorDataValues; +import org.apache.solr.savedsearch.SolrMonitorQueryDecoder; +import org.apache.solr.savedsearch.cache.MonitorQueryCache; class ReverseSearchQuery extends Query { diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/SolrMatcherSink.java similarity index 96% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/SolrMatcherSink.java index d1718c6914e0..1fd2a1c9fd1c 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/SolrMatcherSink.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/SolrMatcherSink.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor.search; +package org.apache.solr.savedsearch.search; import java.io.IOException; import java.util.Map; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/SyncSolrMatcherSink.java similarity index 98% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/SyncSolrMatcherSink.java index a4bf19a4266d..e4c6119e708d 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/SyncSolrMatcherSink.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/SyncSolrMatcherSink.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor.search; +package org.apache.solr.savedsearch.search; import java.io.IOException; import java.util.Map; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/package-info.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/package-info.java similarity index 95% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/search/package-info.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/package-info.java index fa70d0d1b745..0fd177d01376 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/search/package-info.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/package-info.java @@ -18,4 +18,4 @@ */ /** This package contains search logic for Solr's lucene-monitor integration. */ -package org.apache.solr.monitor.search; +package org.apache.solr.savedsearch.search; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/MonitorUpdateProcessorFactory.java similarity index 94% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/MonitorUpdateProcessorFactory.java index 0f4f7e825d3d..d0ea31f3d1a0 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/update/MonitorUpdateProcessorFactory.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/MonitorUpdateProcessorFactory.java @@ -17,12 +17,12 @@ * */ -package org.apache.solr.monitor.update; +package org.apache.solr.savedsearch.update; import org.apache.lucene.monitor.Presearcher; import org.apache.lucene.monitor.QueryDecomposer; import org.apache.solr.core.SolrCore; -import org.apache.solr.monitor.search.ReverseSearchComponent; +import org.apache.solr.savedsearch.search.ReverseSearchComponent; import org.apache.solr.request.SolrQueryRequest; import org.apache.solr.response.SolrQueryResponse; import org.apache.solr.update.processor.UpdateRequestProcessor; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/MonitorUpdateRequestProcessor.java similarity index 98% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/MonitorUpdateRequestProcessor.java index 3f2b77151b85..9bf0a87c3919 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/update/MonitorUpdateRequestProcessor.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/MonitorUpdateRequestProcessor.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor.update; +package org.apache.solr.savedsearch.update; import java.io.IOException; import java.io.Reader; @@ -48,8 +48,8 @@ import org.apache.solr.common.params.CommonParams; import org.apache.solr.common.util.JavaBinCodec; import org.apache.solr.core.SolrCore; -import org.apache.solr.monitor.MonitorSchemaFields; -import org.apache.solr.monitor.SimpleQueryParser; +import org.apache.solr.savedsearch.MonitorSchemaFields; +import org.apache.solr.savedsearch.SimpleQueryParser; import org.apache.solr.schema.IndexSchema; import org.apache.solr.schema.SchemaField; import org.apache.solr.update.AddUpdateCommand; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/monitor/update/package-info.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/package-info.java similarity index 95% rename from solr/modules/saved-search/src/java/org/apache/solr/monitor/update/package-info.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/package-info.java index f6e0586056a9..e87f29ee76cc 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/monitor/update/package-info.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/package-info.java @@ -18,4 +18,4 @@ */ /** This package contains update logic for Solr's lucene-monitor integration. */ -package org.apache.solr.monitor.update; +package org.apache.solr.savedsearch.update; 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 index bfb0de4d082a..356dbc79b97b 100644 --- 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 @@ -81,7 +81,7 @@ - + reverseSearch @@ -121,7 +121,7 @@ + class="solr.savedsearch.search.ReverseSearchComponent"> TermFilteredPresearcher true @@ -129,7 +129,7 @@ - + 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 index 78b2930273d1..534fca33a7d1 100644 --- 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 @@ -66,10 +66,10 @@ autowarmCount="10" regenerator="solr.NoOpRegenerator"/> + regenerator="solr.savedsearch.cache.SharedMonitorCacheLatestRegenerator"/> true 20 200 @@ -86,7 +86,7 @@ - + explicit @@ -122,7 +122,7 @@ + class="solr.savedsearch.search.ReverseSearchComponent"> mySolrMonitorCache MultipassTermFilteredPresearcher true @@ -133,7 +133,7 @@ - + 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 index 3f7c187f7999..04dea59fb91e 100644 --- a/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig.xml +++ b/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig.xml @@ -66,9 +66,9 @@ autowarmCount="10" regenerator="solr.NoOpRegenerator"/> true @@ -87,7 +87,7 @@ - + explicit @@ -123,14 +123,14 @@ + class="solr.savedsearch.search.ReverseSearchComponent"> TermFilteredPresearcher - + diff --git a/solr/modules/saved-search/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/MonitorSolrQueryTest.java similarity index 99% rename from solr/modules/saved-search/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java rename to solr/modules/saved-search/src/test/org/apache/solr/savedsearch/MonitorSolrQueryTest.java index 92ed3d1bff61..1b98025aec08 100644 --- a/solr/modules/saved-search/src/test/org/apache/solr/monitor/MonitorSolrQueryTest.java +++ b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/MonitorSolrQueryTest.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor; +package org.apache.solr.savedsearch; import java.io.IOException; import java.net.URISyntaxException; diff --git a/solr/modules/saved-search/src/test/org/apache/solr/monitor/NoCacheMonitorSolrQueryTest.java b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/NoCacheMonitorSolrQueryTest.java similarity index 96% rename from solr/modules/saved-search/src/test/org/apache/solr/monitor/NoCacheMonitorSolrQueryTest.java rename to solr/modules/saved-search/src/test/org/apache/solr/savedsearch/NoCacheMonitorSolrQueryTest.java index d47ba425f48f..b2ac09cdbbc7 100644 --- a/solr/modules/saved-search/src/test/org/apache/solr/monitor/NoCacheMonitorSolrQueryTest.java +++ b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/NoCacheMonitorSolrQueryTest.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor; +package org.apache.solr.savedsearch; import org.junit.BeforeClass; diff --git a/solr/modules/saved-search/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SingleCoreMonitorSolrTest.java similarity index 99% rename from solr/modules/saved-search/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java rename to solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SingleCoreMonitorSolrTest.java index 31d8bf05af2d..7c7ce0a658b6 100644 --- a/solr/modules/saved-search/src/test/org/apache/solr/monitor/SingleCoreMonitorSolrTest.java +++ b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SingleCoreMonitorSolrTest.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor; +package org.apache.solr.savedsearch; import java.net.URL; import java.nio.charset.StandardCharsets; diff --git a/solr/modules/saved-search/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/StoredMonitorSolrQueryTest.java similarity index 97% rename from solr/modules/saved-search/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java rename to solr/modules/saved-search/src/test/org/apache/solr/savedsearch/StoredMonitorSolrQueryTest.java index e9e37f535508..a7c2ee5eaf7a 100644 --- a/solr/modules/saved-search/src/test/org/apache/solr/monitor/StoredMonitorSolrQueryTest.java +++ b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/StoredMonitorSolrQueryTest.java @@ -17,7 +17,7 @@ * */ -package org.apache.solr.monitor; +package org.apache.solr.savedsearch; import org.apache.lucene.monitor.MonitorFields; import org.junit.BeforeClass; From 4665004b5ead2a61478e5ad6cdc5e30caffa71f4 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Thu, 5 Dec 2024 09:02:24 -0500 Subject: [PATCH 67/85] make SolrResourceLoader aware of savedsearch paths --- .../java/org/apache/solr/core/SolrResourceLoader.java | 6 +++++- .../update/MonitorUpdateProcessorFactory.java | 2 +- .../solr/collection1/solrconfig-no-cache.xml | 6 +++--- .../solr/collection1/solrconfig-single-core.xml | 10 +++++----- .../src/test-files/solr/collection1/solrconfig.xml | 10 +++++----- 5 files changed, 19 insertions(+), 15 deletions(-) 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 11f61a12ae29..64c026ea79b3 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/modules/saved-search/src/java/org/apache/solr/savedsearch/update/MonitorUpdateProcessorFactory.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/MonitorUpdateProcessorFactory.java index d0ea31f3d1a0..e48186b1de5a 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/MonitorUpdateProcessorFactory.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/MonitorUpdateProcessorFactory.java @@ -22,9 +22,9 @@ import org.apache.lucene.monitor.Presearcher; import org.apache.lucene.monitor.QueryDecomposer; import org.apache.solr.core.SolrCore; -import org.apache.solr.savedsearch.search.ReverseSearchComponent; import org.apache.solr.request.SolrQueryRequest; import org.apache.solr.response.SolrQueryResponse; +import org.apache.solr.savedsearch.search.ReverseSearchComponent; import org.apache.solr.update.processor.UpdateRequestProcessor; import org.apache.solr.update.processor.UpdateRequestProcessorFactory; import org.apache.solr.util.plugin.SolrCoreAware; 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 index 356dbc79b97b..b94d4b2284d2 100644 --- 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 @@ -81,7 +81,7 @@ - + reverseSearch @@ -121,7 +121,7 @@ + class="solr.ReverseSearchComponent"> TermFilteredPresearcher true @@ -129,7 +129,7 @@ - + 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 index 534fca33a7d1..812a4f77e429 100644 --- 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 @@ -66,10 +66,10 @@ autowarmCount="10" regenerator="solr.NoOpRegenerator"/> + regenerator="solr.SharedMonitorCacheLatestRegenerator"/> true 20 200 @@ -86,7 +86,7 @@ - + explicit @@ -122,7 +122,7 @@ + class="solr.ReverseSearchComponent"> mySolrMonitorCache MultipassTermFilteredPresearcher true @@ -133,7 +133,7 @@ - + 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 index 04dea59fb91e..69e4216a6a3a 100644 --- a/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig.xml +++ b/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig.xml @@ -66,9 +66,9 @@ autowarmCount="10" regenerator="solr.NoOpRegenerator"/> true @@ -87,7 +87,7 @@ - + explicit @@ -123,14 +123,14 @@ + class="solr.ReverseSearchComponent"> TermFilteredPresearcher - + From 9a45f176e21f9b87a928a007e33575d352c9c66b Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Thu, 5 Dec 2024 09:02:49 -0500 Subject: [PATCH 68/85] fix analyzeDependency error --- solr/modules/saved-search/build.gradle | 1 + 1 file changed, 1 insertion(+) diff --git a/solr/modules/saved-search/build.gradle b/solr/modules/saved-search/build.gradle index 3b9c7bb14a99..32781165e301 100644 --- a/solr/modules/saved-search/build.gradle +++ b/solr/modules/saved-search/build.gradle @@ -26,6 +26,7 @@ dependencies { 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 } From 613b6cdc327a756a4aee5bb9e1a6cf5c866a6b05 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Thu, 5 Dec 2024 12:10:46 -0500 Subject: [PATCH 69/85] rename stuff to SavedSearch* --- ...asingMultipassTermFilteredPresearcher.java | 62 ---- .../solr/savedsearch/AliasingPresearcher.java | 100 +++++- .../AliasingTermFilteredPresearcher.java | 78 ----- ...Values.java => SavedSearchDataValues.java} | 4 +- ...ryDecoder.java => SavedSearchDecoder.java} | 13 +- ...elds.java => SavedSearchSchemaFields.java} | 4 +- ...ache.java => DefaultSavedSearchCache.java} | 38 +-- ...rQueryCache.java => SavedSearchCache.java} | 8 +- ...java => SavedSearchLatestRegenerator.java} | 18 +- .../search/PresearcherFactory.java | 9 +- .../search/ReverseSearchComponent.java | 85 +++-- .../search/ReverseSearchQuery.java | 30 +- .../search/SyncSolrMatcherSink.java | 69 ---- .../update/MonitorUpdateProcessorFactory.java | 52 --- .../update/MonitorUpdateRequestProcessor.java | 269 ---------------- .../SavedSearchUpdateProcessorFactory.java | 299 ++++++++++++++++++ .../dangling-test-single-doc-batch.json | 2 +- .../src/test-files/monitor/doc0.json | 2 +- .../src/test-files/monitor/doc1.json | 2 +- .../src/test-files/monitor/doc2.json | 2 +- .../src/test-files/monitor/elevator-doc.json | 2 +- .../test-files/monitor/multi-value-doc.json | 2 +- .../solr/collection1/schema-aliasing.xml | 2 +- .../solr/collection1/solrconfig-no-cache.xml | 2 +- .../collection1/solrconfig-single-core.xml | 8 +- .../solr/collection1/solrconfig.xml | 8 +- ...yTest.java => NoCacheSavedSearchTest.java} | 2 +- ...olrQueryTest.java => SavedSearchTest.java} | 2 +- ...st.java => SingleCoreSavedSearchTest.java} | 2 +- ...ryTest.java => StoredSavedSearchTest.java} | 2 +- 30 files changed, 540 insertions(+), 638 deletions(-) delete mode 100644 solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingMultipassTermFilteredPresearcher.java delete mode 100644 solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingTermFilteredPresearcher.java rename solr/modules/saved-search/src/java/org/apache/solr/savedsearch/{MonitorDataValues.java => SavedSearchDataValues.java} (95%) rename solr/modules/saved-search/src/java/org/apache/solr/savedsearch/{SolrMonitorQueryDecoder.java => SavedSearchDecoder.java} (82%) rename solr/modules/saved-search/src/java/org/apache/solr/savedsearch/{MonitorSchemaFields.java => SavedSearchSchemaFields.java} (93%) rename solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/{SharedMonitorCache.java => DefaultSavedSearchCache.java} (89%) rename solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/{MonitorQueryCache.java => SavedSearchCache.java} (81%) rename solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/{SharedMonitorCacheLatestRegenerator.java => SavedSearchLatestRegenerator.java} (84%) delete mode 100644 solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/SyncSolrMatcherSink.java delete mode 100644 solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/MonitorUpdateProcessorFactory.java delete mode 100644 solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/MonitorUpdateRequestProcessor.java create mode 100644 solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/SavedSearchUpdateProcessorFactory.java rename solr/modules/saved-search/src/test/org/apache/solr/savedsearch/{NoCacheMonitorSolrQueryTest.java => NoCacheSavedSearchTest.java} (93%) rename solr/modules/saved-search/src/test/org/apache/solr/savedsearch/{MonitorSolrQueryTest.java => SavedSearchTest.java} (99%) rename solr/modules/saved-search/src/test/org/apache/solr/savedsearch/{SingleCoreMonitorSolrTest.java => SingleCoreSavedSearchTest.java} (99%) rename solr/modules/saved-search/src/test/org/apache/solr/savedsearch/{StoredMonitorSolrQueryTest.java => StoredSavedSearchTest.java} (94%) diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingMultipassTermFilteredPresearcher.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingMultipassTermFilteredPresearcher.java deleted file mode 100644 index d3702033eca5..000000000000 --- a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingMultipassTermFilteredPresearcher.java +++ /dev/null @@ -1,62 +0,0 @@ -/* - * - * * 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 static org.apache.solr.savedsearch.AliasingTermFilteredPresearcher.AliasingDocumentQueryBuilder; - -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.TermWeightor; - -public class AliasingMultipassTermFilteredPresearcher extends MultipassTermFilteredPresearcher { - - private final String prefix; - - private AliasingMultipassTermFilteredPresearcher( - 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 AliasingDocumentQueryBuilder(super.getQueryBuilder(), prefix); - } - - public static AliasingPresearcher build( - int passes, - float minWeight, - TermWeightor weightor, - List queryHandlers, - Set filterFields, - String prefix) { - return new AliasingPresearcher( - new AliasingMultipassTermFilteredPresearcher( - passes, minWeight, weightor, queryHandlers, filterFields, prefix), - prefix); - } -} 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 index 9d1ea18e2e28..ef001a1d7ed0 100644 --- 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 @@ -19,23 +19,29 @@ 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 fields 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.monitor.ParallelMonitorSolrQueryTest#coexistWithRegularDocumentsTest}. In the + * 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 @@ -83,4 +89,88 @@ private Document alias(Document in) { } 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/AliasingTermFilteredPresearcher.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingTermFilteredPresearcher.java deleted file mode 100644 index 535eb2aed989..000000000000 --- a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/AliasingTermFilteredPresearcher.java +++ /dev/null @@ -1,78 +0,0 @@ -/* - * - * * 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.Set; -import org.apache.lucene.monitor.CustomQueryHandler; -import org.apache.lucene.monitor.TermFilteredPresearcher; -import org.apache.lucene.monitor.TermWeightor; -import org.apache.lucene.search.Query; -import org.apache.lucene.util.BytesRef; - -public class AliasingTermFilteredPresearcher extends TermFilteredPresearcher { - - private final String prefix; - - AliasingTermFilteredPresearcher( - 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 AliasingTermFilteredPresearcher(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/MonitorDataValues.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchDataValues.java similarity index 95% rename from solr/modules/saved-search/src/java/org/apache/solr/savedsearch/MonitorDataValues.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchDataValues.java index d24975219f25..8b85145d25c8 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/MonitorDataValues.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchDataValues.java @@ -28,7 +28,7 @@ import org.apache.lucene.search.DocIdSetIterator; import org.apache.solr.common.params.CommonParams; -public class MonitorDataValues { +public class SavedSearchDataValues { private final SortedDocValues queryIdIt; private final SortedDocValues cacheIdIt; @@ -37,7 +37,7 @@ public class MonitorDataValues { private final LeafReader reader; private int currentDoc; - public MonitorDataValues(LeafReaderContext context) throws IOException { + public SavedSearchDataValues(LeafReaderContext context) throws IOException { reader = context.reader(); cacheIdIt = reader.getSortedDocValues(MonitorFields.CACHE_ID); queryIdIt = reader.getSortedDocValues(MonitorFields.QUERY_ID); diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SolrMonitorQueryDecoder.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchDecoder.java similarity index 82% rename from solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SolrMonitorQueryDecoder.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchDecoder.java index edf3f4a452c9..a2bd6ae5ef57 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SolrMonitorQueryDecoder.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchDecoder.java @@ -27,12 +27,12 @@ import org.apache.solr.core.SolrCore; import org.apache.solr.savedsearch.search.ReverseSearchComponent; -public class SolrMonitorQueryDecoder { +public class SavedSearchDecoder { private final SolrCore core; private final QueryDecomposer queryDecomposer; - public SolrMonitorQueryDecoder(SolrCore core) { + public SavedSearchDecoder(SolrCore core) { this.core = core; ReverseSearchComponent rsc = (ReverseSearchComponent) @@ -40,14 +40,15 @@ public SolrMonitorQueryDecoder(SolrCore core) { this.queryDecomposer = rsc.getQueryDecomposer(); } - private MonitorQuery decode(MonitorDataValues monitorDataValues) throws IOException { - String id = monitorDataValues.getQueryId(); - String queryStr = monitorDataValues.getMq(); + 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(MonitorDataValues dataValues, String cacheId) throws IOException { + public QCEVisitor getComponent(SavedSearchDataValues dataValues, String cacheId) + throws IOException { for (QCEVisitor qce : QCEVisitor.decompose(decode(dataValues), queryDecomposer)) { if (qce.getCacheId().equals(cacheId)) { return qce; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/MonitorSchemaFields.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchSchemaFields.java similarity index 93% rename from solr/modules/saved-search/src/java/org/apache/solr/savedsearch/MonitorSchemaFields.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchSchemaFields.java index 4b8e6cd222be..ef011cf9f9fb 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/MonitorSchemaFields.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchSchemaFields.java @@ -23,13 +23,13 @@ import org.apache.solr.schema.IndexSchema; import org.apache.solr.schema.SchemaField; -public class MonitorSchemaFields { +public class SavedSearchSchemaFields { private final SchemaField cacheId; private final SchemaField queryId; private final SchemaField monitorQuery; - public MonitorSchemaFields(IndexSchema indexSchema) { + 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); diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SharedMonitorCache.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/DefaultSavedSearchCache.java similarity index 89% rename from solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SharedMonitorCache.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/DefaultSavedSearchCache.java index 9ff0bad302df..2e89e0d51930 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SharedMonitorCache.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/DefaultSavedSearchCache.java @@ -38,17 +38,17 @@ import org.apache.solr.common.SolrException.ErrorCode; import org.apache.solr.metrics.MetricsMap; import org.apache.solr.metrics.SolrMetricsContext; -import org.apache.solr.savedsearch.MonitorDataValues; -import org.apache.solr.savedsearch.SolrMonitorQueryDecoder; +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 SharedMonitorCache extends SolrCacheBase +public class DefaultSavedSearchCache extends SolrCacheBase implements SolrCache, - MonitorQueryCache, + SavedSearchCache, RemovalListener { private static final long START_HIGH_WATER_MARK = -1; @@ -75,7 +75,7 @@ public class SharedMonitorCache extends SolrCacheBase @Override public VersionedQueryCacheEntry computeIfStale( - MonitorDataValues dataValues, SolrMonitorQueryDecoder decoder) throws IOException { + SavedSearchDataValues dataValues, SavedSearchDecoder decoder) throws IOException { return mqCacheMap() .compute( dataValues.getCacheId(), @@ -173,11 +173,11 @@ public void clear() { @Override public void warm(SolrIndexSearcher searcher, SolrCache old) { try { - SharedMonitorCache oldSharedMonitorCache = - old instanceof SharedMonitorCache ? (SharedMonitorCache) old : null; - if (oldSharedMonitorCache != null) { - mqCache = oldSharedMonitorCache.mqCache; - versionHighWaterMark = oldSharedMonitorCache.versionHighWaterMark; + DefaultSavedSearchCache oldDefaultSavedSearchCache = + old instanceof DefaultSavedSearchCache ? (DefaultSavedSearchCache) old : null; + if (oldDefaultSavedSearchCache != null) { + mqCache = oldDefaultSavedSearchCache.mqCache; + versionHighWaterMark = oldDefaultSavedSearchCache.versionHighWaterMark; } if (regenerator != null) { long nanoStart = System.nanoTime(); @@ -185,13 +185,13 @@ public void warm(SolrIndexSearcher searcher, SolrCache prevEntry.version) { @@ -290,7 +290,7 @@ private VersionedQueryCacheEntry compute( } return prevEntry; } catch (Exception e) { - throw new SolrException(ErrorCode.INVALID_STATE, "Failed to update MonitorQueryCache", e); + throw new SolrException(ErrorCode.INVALID_STATE, "Failed to update SavedSearchCache", e); } } diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/MonitorQueryCache.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SavedSearchCache.java similarity index 81% rename from solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/MonitorQueryCache.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SavedSearchCache.java index d571843756a9..32208f47172d 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/MonitorQueryCache.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SavedSearchCache.java @@ -21,13 +21,13 @@ import java.io.IOException; import org.apache.lucene.util.BytesRef; -import org.apache.solr.savedsearch.MonitorDataValues; -import org.apache.solr.savedsearch.SolrMonitorQueryDecoder; +import org.apache.solr.savedsearch.SavedSearchDataValues; +import org.apache.solr.savedsearch.SavedSearchDecoder; -public interface MonitorQueryCache { +public interface SavedSearchCache { VersionedQueryCacheEntry computeIfStale( - MonitorDataValues dataValues, SolrMonitorQueryDecoder decoder) throws IOException; + 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/SharedMonitorCacheLatestRegenerator.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SavedSearchLatestRegenerator.java similarity index 84% rename from solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SharedMonitorCacheLatestRegenerator.java rename to solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SavedSearchLatestRegenerator.java index 732dae3c5c43..71655001129e 100644 --- a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SharedMonitorCacheLatestRegenerator.java +++ b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SavedSearchLatestRegenerator.java @@ -25,13 +25,13 @@ import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; import org.apache.solr.common.params.CommonParams; -import org.apache.solr.savedsearch.MonitorDataValues; -import org.apache.solr.savedsearch.SolrMonitorQueryDecoder; +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 SharedMonitorCacheLatestRegenerator implements CacheRegenerator { +public class SavedSearchLatestRegenerator implements CacheRegenerator { private static final int MAX_BATCH_SIZE = 1 << 10; @@ -43,13 +43,13 @@ public boolean regenerateItem( K oldKey, V oldVal) throws IOException { - if (!(newCache instanceof SharedMonitorCache)) { + if (!(newCache instanceof DefaultSavedSearchCache)) { throw new IllegalArgumentException( this.getClass().getSimpleName() + " only supports " - + SharedMonitorCache.class.getSimpleName()); + + DefaultSavedSearchCache.class.getSimpleName()); } - var cache = (SharedMonitorCache) newCache; + var cache = (DefaultSavedSearchCache) newCache; var reader = searcher.getIndexReader(); int batchSize = Math.min(MAX_BATCH_SIZE, cache.getInitialSize()); var topDocs = @@ -57,11 +57,11 @@ public boolean regenerateItem( .search(versionRangeQuery(cache), batchSize) .scoreDocs; int batchesRemaining = cache.getInitialSize() / batchSize - 1; - SolrMonitorQueryDecoder decoder = new SolrMonitorQueryDecoder(searcher.getCore()); + SavedSearchDecoder decoder = new SavedSearchDecoder(searcher.getCore()); while (topDocs.length > 0 && batchesRemaining > 0) { int docIndex = 0; for (LeafReaderContext ctx : reader.leaves()) { - MonitorDataValues dataValues = new MonitorDataValues(ctx); + SavedSearchDataValues dataValues = new SavedSearchDataValues(ctx); int shiftedMax = ctx.reader().maxDoc() + ctx.docBase; while (docIndex < topDocs.length && topDocs[docIndex].doc >= ctx.docBase @@ -86,7 +86,7 @@ public boolean regenerateItem( return false; } - private static Query versionRangeQuery(SharedMonitorCache cache) { + 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/search/PresearcherFactory.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/PresearcherFactory.java index 9a8cc275afbb..0452b891537b 100644 --- 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 @@ -28,8 +28,7 @@ import org.apache.lucene.monitor.TermFilteredPresearcher; import org.apache.lucene.monitor.TermWeightor; import org.apache.lucene.util.ResourceLoader; -import org.apache.solr.savedsearch.AliasingMultipassTermFilteredPresearcher; -import org.apache.solr.savedsearch.AliasingTermFilteredPresearcher; +import org.apache.solr.savedsearch.AliasingPresearcher; public class PresearcherFactory { @@ -39,7 +38,7 @@ public class PresearcherFactory { // 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 = - "_________________________________________________monitor_alias_"; + "_________________________________________________saved_search_alias_"; public static final String TERM_FILTERED = TermFilteredPresearcher.class.getSimpleName(); public static final String MULTI_PASS_TERM_FILTERED = @@ -63,7 +62,7 @@ static Presearcher build( if (TERM_FILTERED.equals(type)) { if (presearcherParameters.applyFieldNameAlias) { presearcher = - AliasingTermFilteredPresearcher.build( + AliasingPresearcher.TermFiltered.build( weightor, customQueryHandlers, filterFields, presearcherParameters.aliasPrefix); } else { presearcher = new TermFilteredPresearcher(weightor, customQueryHandlers, filterFields); @@ -71,7 +70,7 @@ static Presearcher build( } else { if (presearcherParameters.applyFieldNameAlias) { presearcher = - AliasingMultipassTermFilteredPresearcher.build( + AliasingPresearcher.MultiPassTermFiltered.build( presearcherParameters.numberOfPasses, presearcherParameters.minWeight, weightor, 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 index dc175605e5db..d8daecc04b8e 100644 --- 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 @@ -28,9 +28,12 @@ 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.DocumentBatchVisitor; import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.monitor.Presearcher; @@ -49,9 +52,9 @@ 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.SolrMonitorQueryDecoder; -import org.apache.solr.savedsearch.cache.MonitorQueryCache; -import org.apache.solr.savedsearch.cache.SharedMonitorCache; +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; @@ -62,10 +65,10 @@ public class ReverseSearchComponent extends QueryComponent implements SolrCoreAw public static final String COMPONENT_NAME = "reverseSearch"; - private static final String SOLR_MONITOR_CACHE_NAME_KEY = "solrMonitorCacheName"; - private static final String SOLR_MONITOR_CACHE_NAME_DEFAULT = "solrMonitorCache"; - private static final String MONITOR_DOCUMENTS_KEY = "monitorDocuments"; - private String solrMonitorCacheName = SOLR_MONITOR_CACHE_NAME_DEFAULT; + 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; @@ -74,9 +77,9 @@ public class ReverseSearchComponent extends QueryComponent implements SolrCoreAw @Override public void init(NamedList args) { super.init(args); - Object solrMonitorCacheName = args.remove(SOLR_MONITOR_CACHE_NAME_KEY); - if (solrMonitorCacheName != null) { - this.solrMonitorCacheName = (String) solrMonitorCacheName; + Object savedSearchCacheName = args.remove(SAVED_SEARCH_CACHE_NAME_KEY); + if (savedSearchCacheName != null) { + this.savedSearchCacheName = (String) savedSearchCacheName; } presearcherParameters = new PresearcherFactory.PresearcherParameters(); SolrPluginUtils.invokeSetters(presearcherParameters, args); @@ -89,17 +92,17 @@ public void prepare(ResponseBuilder rb) throws IOException { documentBatchVisitor(rb.req.getJSON(), rb.req.getSchema())) { final LeafReader documentBatch = documentBatchVisitor.get(); - final MonitorQueryCache monitorQueryCache = - (SharedMonitorCache) rb.req.getSearcher().getCache(this.solrMonitorCacheName); + final SavedSearchCache savedSearchCache = + (DefaultSavedSearchCache) rb.req.getSearcher().getCache(this.savedSearchCacheName); final BiPredicate termAcceptor; - if (monitorQueryCache == null) { + if (savedSearchCache == null) { termAcceptor = (__, ___) -> true; } else { - termAcceptor = monitorQueryCache::acceptTerm; + termAcceptor = savedSearchCache::acceptTerm; } final Query preFilterQuery = presearcher.buildQuery(documentBatch, termAcceptor); - rb.setQuery(reverseSearchQuery(preFilterQuery, rb, documentBatch, monitorQueryCache)); + rb.setQuery(reverseSearchQuery(preFilterQuery, rb, documentBatch, savedSearchCache)); } } @@ -107,18 +110,17 @@ private static ReverseSearchQuery reverseSearchQuery( Query preFilterQuery, ResponseBuilder rb, LeafReader documentBatch, - MonitorQueryCache monitorQueryCache) { - final SolrMonitorQueryDecoder solrMonitorQueryDecoder = - new SolrMonitorQueryDecoder(rb.req.getCore()); + SavedSearchCache savedSearchCache) { + final SavedSearchDecoder savedSearchDecoder = new SavedSearchDecoder(rb.req.getCore()); final SolrMatcherSink solrMatcherSink = - new SyncSolrMatcherSink<>( + new DefaultSolrMatcherSink<>( QueryMatch.SIMPLE_MATCHER::createMatcher, new IndexSearcher(documentBatch)); rb.req.getContext().put(SolrMatcherSink.class.getSimpleName(), solrMatcherSink); final ReverseSearchQuery.ReverseSearchContext context = new ReverseSearchQuery.ReverseSearchContext( - monitorQueryCache, solrMonitorQueryDecoder, solrMatcherSink); + savedSearchCache, savedSearchDecoder, solrMatcherSink); return new ReverseSearchQuery(context, preFilterQuery); } @@ -151,7 +153,7 @@ private static DocumentBatchVisitor documentBatchVisitor( throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "need params"); } Map paramMap = (Map) jsonParams; - Object documents = paramMap.get(MONITOR_DOCUMENTS_KEY); + Object documents = paramMap.get(REVERSE_SEARCH_DOCUMENTS_KEY); if (!(documents instanceof List)) { throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "need documents list"); } @@ -238,4 +240,45 @@ public QueryDecomposer getQueryDecomposer() { 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/ReverseSearchQuery.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/ReverseSearchQuery.java index cc73b1b4e219..6e2c03404257 100644 --- 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 @@ -36,9 +36,9 @@ import org.apache.lucene.search.ScorerSupplier; import org.apache.lucene.search.TwoPhaseIterator; import org.apache.lucene.search.Weight; -import org.apache.solr.savedsearch.MonitorDataValues; -import org.apache.solr.savedsearch.SolrMonitorQueryDecoder; -import org.apache.solr.savedsearch.cache.MonitorQueryCache; +import org.apache.solr.savedsearch.SavedSearchDataValues; +import org.apache.solr.savedsearch.SavedSearchDecoder; +import org.apache.solr.savedsearch.cache.SavedSearchCache; class ReverseSearchQuery extends Query { @@ -160,11 +160,11 @@ static class ReverseSearchScorer extends Scorer { private static final float MATCH_COST = 100.0f; private final Scorer presearchScorer; - private final MonitorQueryCache monitorQueryCache; - private final SolrMonitorQueryDecoder queryDecoder; + private final SavedSearchCache savedSearchCache; + private final SavedSearchDecoder queryDecoder; private final SolrMatcherSink matcherSink; private final Metadata metadata; - private final MonitorDataValues dataValues; + private final SavedSearchDataValues dataValues; ReverseSearchScorer( Scorer presearchScorer, @@ -173,12 +173,12 @@ static class ReverseSearchScorer extends Scorer { throws IOException { super(presearchScorer.getWeight()); this.presearchScorer = presearchScorer; - this.monitorQueryCache = reverseSearchContext.queryCache; + this.savedSearchCache = reverseSearchContext.queryCache; this.queryDecoder = reverseSearchContext.queryDecoder; this.matcherSink = reverseSearchContext.solrMatcherSink; this.metadata = new Metadata(); matcherSink.captureMetadata(metadata); - this.dataValues = new MonitorDataValues(leafReaderContext); + this.dataValues = new SavedSearchDataValues(leafReaderContext); } @Override @@ -252,11 +252,11 @@ public boolean matches() throws IOException { return false; } - private QCEVisitor getEntry(MonitorDataValues dataValues) throws IOException { + private QCEVisitor getEntry(SavedSearchDataValues dataValues) throws IOException { var versionedEntry = - monitorQueryCache == null + savedSearchCache == null ? null - : monitorQueryCache.computeIfStale(dataValues, queryDecoder); + : savedSearchCache.computeIfStale(dataValues, queryDecoder); return (versionedEntry == null || versionedEntry.version != dataValues.getVersion()) ? queryDecoder.getComponent(dataValues, dataValues.getCacheId()) : versionedEntry.entry; @@ -272,13 +272,13 @@ public float matchCost() { static class ReverseSearchContext { - private final MonitorQueryCache queryCache; - private final SolrMonitorQueryDecoder queryDecoder; + private final SavedSearchCache queryCache; + private final SavedSearchDecoder queryDecoder; private final SolrMatcherSink solrMatcherSink; ReverseSearchContext( - MonitorQueryCache queryCache, - SolrMonitorQueryDecoder queryDecoder, + SavedSearchCache queryCache, + SavedSearchDecoder queryDecoder, SolrMatcherSink solrMatcherSink) { this.queryCache = queryCache; this.queryDecoder = queryDecoder; diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/SyncSolrMatcherSink.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/SyncSolrMatcherSink.java deleted file mode 100644 index e4c6119e708d..000000000000 --- a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/search/SyncSolrMatcherSink.java +++ /dev/null @@ -1,69 +0,0 @@ -/* - * - * * 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 java.util.concurrent.ConcurrentHashMap; -import java.util.function.Function; -import org.apache.lucene.monitor.CandidateMatcher; -import org.apache.lucene.monitor.QueryMatch; -import org.apache.lucene.search.IndexSearcher; -import org.apache.lucene.search.Query; - -class SyncSolrMatcherSink implements SolrMatcherSink { - - private final Function> matcherFactory; - private final IndexSearcher docBatchSearcher; - private final ConcurrentHashMap.KeySetView metadataSet = - ConcurrentHashMap.newKeySet(); - - SyncSolrMatcherSink( - 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/update/MonitorUpdateProcessorFactory.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/MonitorUpdateProcessorFactory.java deleted file mode 100644 index e48186b1de5a..000000000000 --- a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/MonitorUpdateProcessorFactory.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - * - * * 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 org.apache.lucene.monitor.Presearcher; -import org.apache.lucene.monitor.QueryDecomposer; -import org.apache.solr.core.SolrCore; -import org.apache.solr.request.SolrQueryRequest; -import org.apache.solr.response.SolrQueryResponse; -import org.apache.solr.savedsearch.search.ReverseSearchComponent; -import org.apache.solr.update.processor.UpdateRequestProcessor; -import org.apache.solr.update.processor.UpdateRequestProcessorFactory; -import org.apache.solr.util.plugin.SolrCoreAware; - -public class MonitorUpdateProcessorFactory extends UpdateRequestProcessorFactory - implements SolrCoreAware { - - private QueryDecomposer queryDecomposer; - private Presearcher presearcher; - - @Override - public UpdateRequestProcessor getInstance( - SolrQueryRequest req, SolrQueryResponse rsp, UpdateRequestProcessor next) { - return new MonitorUpdateRequestProcessor(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(); - } -} diff --git a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/MonitorUpdateRequestProcessor.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/MonitorUpdateRequestProcessor.java deleted file mode 100644 index 9bf0a87c3919..000000000000 --- a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/MonitorUpdateRequestProcessor.java +++ /dev/null @@ -1,269 +0,0 @@ -/* - * - * * 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.MonitorFields; -import org.apache.lucene.monitor.MonitorQuery; -import org.apache.lucene.monitor.Presearcher; -import org.apache.lucene.monitor.QCEVisitor; -import org.apache.lucene.monitor.QueryDecomposer; -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.savedsearch.MonitorSchemaFields; -import org.apache.solr.savedsearch.SimpleQueryParser; -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; - -public class MonitorUpdateRequestProcessor extends UpdateRequestProcessor { - - private final SolrCore core; - private final IndexSchema indexSchema; - private final QueryDecomposer queryDecomposer; - private final Presearcher presearcher; - private final MonitorSchemaFields monitorSchemaFields; - private final Set allowedFieldNames; - - public MonitorUpdateRequestProcessor( - UpdateRequestProcessor next, - SolrCore core, - QueryDecomposer queryDecomposer, - Presearcher presearcher) { - super(next); - this.core = core; - this.indexSchema = core.getLatestSchema(); - this.queryDecomposer = queryDecomposer; - this.presearcher = presearcher; - this.monitorSchemaFields = new MonitorSchemaFields(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(monitorSchemaFields.getQueryId().createField(qce.getQueryId())); - doc.add(monitorSchemaFields.getCacheId().createField(qce.getCacheId())); - doc.add( - monitorSchemaFields.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/SavedSearchUpdateProcessorFactory.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/update/SavedSearchUpdateProcessorFactory.java new file mode 100644 index 000000000000..d7232c166133 --- /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.MonitorFields; +import org.apache.lucene.monitor.MonitorQuery; +import org.apache.lucene.monitor.Presearcher; +import org.apache.lucene.monitor.QCEVisitor; +import org.apache.lucene.monitor.QueryDecomposer; +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/test-files/monitor/dangling-test-single-doc-batch.json b/solr/modules/saved-search/src/test-files/monitor/dangling-test-single-doc-batch.json index 46be81547e4e..19d5fff4a76c 100644 --- 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 @@ -1,6 +1,6 @@ { "params": { - "monitorDocuments": [ + "reverseSearchDocuments": [ { "id": "0", "content1_s": "lift" diff --git a/solr/modules/saved-search/src/test-files/monitor/doc0.json b/solr/modules/saved-search/src/test-files/monitor/doc0.json index ca9e136e5bc5..40ee08fd3eea 100644 --- a/solr/modules/saved-search/src/test-files/monitor/doc0.json +++ b/solr/modules/saved-search/src/test-files/monitor/doc0.json @@ -1,6 +1,6 @@ { "params": { - "monitorDocuments": [ + "reverseSearchDocuments": [ { "content_s": "elevator stairs" } diff --git a/solr/modules/saved-search/src/test-files/monitor/doc1.json b/solr/modules/saved-search/src/test-files/monitor/doc1.json index 7dbcd20bccae..af95e4a35a16 100644 --- a/solr/modules/saved-search/src/test-files/monitor/doc1.json +++ b/solr/modules/saved-search/src/test-files/monitor/doc1.json @@ -1,6 +1,6 @@ { "params": { - "monitorDocuments": [ + "reverseSearchDocuments": [ { "content_s": "something else" } diff --git a/solr/modules/saved-search/src/test-files/monitor/doc2.json b/solr/modules/saved-search/src/test-files/monitor/doc2.json index 9ce2cb2a549d..386b3bb68ad5 100644 --- a/solr/modules/saved-search/src/test-files/monitor/doc2.json +++ b/solr/modules/saved-search/src/test-files/monitor/doc2.json @@ -1,6 +1,6 @@ { "params": { - "monitorDocuments": [ + "reverseSearchDocuments": [ { "content_s": "more weird content", "other_content_s": "solr is cool" 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 index d73dd5d0d0f1..83dcec61e805 100644 --- a/solr/modules/saved-search/src/test-files/monitor/elevator-doc.json +++ b/solr/modules/saved-search/src/test-files/monitor/elevator-doc.json @@ -1,6 +1,6 @@ { "params": { - "monitorDocuments": [ + "reverseSearchDocuments": [ { "id": "0", "content0_s": "elevator stairs", 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 index 29a35916a906..8984517c33a0 100644 --- 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 @@ -1,6 +1,6 @@ { "params": { - "monitorDocuments": [ + "reverseSearchDocuments": [ { "id": "4", "content_s": ["elevator stairs", "something else", "test test test"], 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 index 9b3c7289aebb..10d2e55deaf3 100644 --- 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 @@ -96,6 +96,6 @@ - + \ 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 index b94d4b2284d2..d9f7389e65fe 100644 --- 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 @@ -129,7 +129,7 @@ - + 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 index 812a4f77e429..26a2a9d09338 100644 --- 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 @@ -66,10 +66,10 @@ autowarmCount="10" regenerator="solr.NoOpRegenerator"/> + regenerator="solr.SavedSearchLatestRegenerator"/> true 20 200 @@ -123,7 +123,7 @@ - mySolrMonitorCache + mySolrMonitorCache MultipassTermFilteredPresearcher true 4 @@ -133,7 +133,7 @@ - + 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 index 69e4216a6a3a..c5fb6fbd90ea 100644 --- a/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig.xml +++ b/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig.xml @@ -65,10 +65,10 @@ initialSize="0" autowarmCount="10" regenerator="solr.NoOpRegenerator"/> - true @@ -130,7 +130,7 @@ - + diff --git a/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/NoCacheMonitorSolrQueryTest.java b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/NoCacheSavedSearchTest.java similarity index 93% rename from solr/modules/saved-search/src/test/org/apache/solr/savedsearch/NoCacheMonitorSolrQueryTest.java rename to solr/modules/saved-search/src/test/org/apache/solr/savedsearch/NoCacheSavedSearchTest.java index b2ac09cdbbc7..bebb3030cc2e 100644 --- a/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/NoCacheMonitorSolrQueryTest.java +++ b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/NoCacheSavedSearchTest.java @@ -21,7 +21,7 @@ import org.junit.BeforeClass; -public class NoCacheMonitorSolrQueryTest extends MonitorSolrQueryTest { +public class NoCacheSavedSearchTest extends SavedSearchTest { @BeforeClass public static void beforeSuperClass() { diff --git a/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/MonitorSolrQueryTest.java b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SavedSearchTest.java similarity index 99% rename from solr/modules/saved-search/src/test/org/apache/solr/savedsearch/MonitorSolrQueryTest.java rename to solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SavedSearchTest.java index 1b98025aec08..952c531aa10c 100644 --- a/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/MonitorSolrQueryTest.java +++ b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SavedSearchTest.java @@ -34,7 +34,7 @@ import org.junit.Test; @SuppressWarnings("unchecked") -public class MonitorSolrQueryTest extends BaseDistributedSearchTestCase { +public class SavedSearchTest extends BaseDistributedSearchTestCase { @Test public void testMonitorQuery() throws Exception { diff --git a/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SingleCoreMonitorSolrTest.java b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SingleCoreSavedSearchTest.java similarity index 99% rename from solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SingleCoreMonitorSolrTest.java rename to solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SingleCoreSavedSearchTest.java index 7c7ce0a658b6..f9f9bd2bb88d 100644 --- a/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SingleCoreMonitorSolrTest.java +++ b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/SingleCoreSavedSearchTest.java @@ -33,7 +33,7 @@ import org.junit.BeforeClass; import org.junit.Test; -public class SingleCoreMonitorSolrTest extends SolrTestCaseJ4 { +public class SingleCoreSavedSearchTest extends SolrTestCaseJ4 { private final String monitorChain = "monitor"; diff --git a/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/StoredMonitorSolrQueryTest.java b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/StoredSavedSearchTest.java similarity index 94% rename from solr/modules/saved-search/src/test/org/apache/solr/savedsearch/StoredMonitorSolrQueryTest.java rename to solr/modules/saved-search/src/test/org/apache/solr/savedsearch/StoredSavedSearchTest.java index a7c2ee5eaf7a..36942debda37 100644 --- a/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/StoredMonitorSolrQueryTest.java +++ b/solr/modules/saved-search/src/test/org/apache/solr/savedsearch/StoredSavedSearchTest.java @@ -23,7 +23,7 @@ import org.junit.BeforeClass; import org.junit.Test; -public class StoredMonitorSolrQueryTest extends MonitorSolrQueryTest { +public class StoredSavedSearchTest extends SavedSearchTest { @BeforeClass public static void beforeSuperClass() { From 2ad0db2ace954e9afc22a5d121d3ff454e064a3b Mon Sep 17 00:00:00 2001 From: lkotzaniewsk Date: Mon, 9 Dec 2024 22:26:51 -0500 Subject: [PATCH 70/85] consolidate lucene-monitor visitors --- .../lucene/monitor/DocumentBatchVisitor.java | 63 -------- .../apache/lucene/monitor/MonitorFields.java | 32 ----- .../org/apache/lucene/monitor/QCEVisitor.java | 63 -------- .../monitor/QueryTermFilterVisitor.java | 39 ----- .../org/apache/lucene/monitor/Visitors.java | 136 ++++++++++++++++++ .../savedsearch/SavedSearchDataValues.java | 2 +- .../solr/savedsearch/SavedSearchDecoder.java | 2 +- .../savedsearch/SavedSearchSchemaFields.java | 2 +- .../cache/DefaultSavedSearchCache.java | 4 +- .../cache/VersionedQueryCacheEntry.java | 2 +- .../search/ReverseSearchComponent.java | 4 +- .../search/ReverseSearchQuery.java | 2 +- .../SavedSearchUpdateProcessorFactory.java | 4 +- .../solr/savedsearch/SavedSearchTest.java | 2 +- .../SingleCoreSavedSearchTest.java | 2 +- .../savedsearch/StoredSavedSearchTest.java | 2 +- 16 files changed, 150 insertions(+), 211 deletions(-) delete mode 100644 solr/modules/saved-search/src/java/org/apache/lucene/monitor/DocumentBatchVisitor.java delete mode 100644 solr/modules/saved-search/src/java/org/apache/lucene/monitor/MonitorFields.java delete mode 100644 solr/modules/saved-search/src/java/org/apache/lucene/monitor/QCEVisitor.java delete mode 100644 solr/modules/saved-search/src/java/org/apache/lucene/monitor/QueryTermFilterVisitor.java create mode 100644 solr/modules/saved-search/src/java/org/apache/lucene/monitor/Visitors.java diff --git a/solr/modules/saved-search/src/java/org/apache/lucene/monitor/DocumentBatchVisitor.java b/solr/modules/saved-search/src/java/org/apache/lucene/monitor/DocumentBatchVisitor.java deleted file mode 100644 index 2518d5a7634f..000000000000 --- a/solr/modules/saved-search/src/java/org/apache/lucene/monitor/DocumentBatchVisitor.java +++ /dev/null @@ -1,63 +0,0 @@ -/* - * - * * 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.List; -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.LeafReader; - -public 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(" ")); - } -} diff --git a/solr/modules/saved-search/src/java/org/apache/lucene/monitor/MonitorFields.java b/solr/modules/saved-search/src/java/org/apache/lucene/monitor/MonitorFields.java deleted file mode 100644 index 7e064d677e7c..000000000000 --- a/solr/modules/saved-search/src/java/org/apache/lucene/monitor/MonitorFields.java +++ /dev/null @@ -1,32 +0,0 @@ -/* - * - * * 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.util.Set; - -public 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); -} diff --git a/solr/modules/saved-search/src/java/org/apache/lucene/monitor/QCEVisitor.java b/solr/modules/saved-search/src/java/org/apache/lucene/monitor/QCEVisitor.java deleted file mode 100644 index 963ce8d27b31..000000000000 --- a/solr/modules/saved-search/src/java/org/apache/lucene/monitor/QCEVisitor.java +++ /dev/null @@ -1,63 +0,0 @@ -/* - * - * * 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.util.ArrayList; -import java.util.List; -import java.util.Map; -import org.apache.lucene.search.Query; - -public 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/lucene/monitor/QueryTermFilterVisitor.java b/solr/modules/saved-search/src/java/org/apache/lucene/monitor/QueryTermFilterVisitor.java deleted file mode 100644 index 3c5c692dd3f1..000000000000 --- a/solr/modules/saved-search/src/java/org/apache/lucene/monitor/QueryTermFilterVisitor.java +++ /dev/null @@ -1,39 +0,0 @@ -/* - * - * * 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.function.BiPredicate; -import org.apache.lucene.index.IndexReader; -import org.apache.lucene.util.BytesRef; - -public 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); - } -} 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 000000000000..b21abfdc0271 --- /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/SavedSearchDataValues.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchDataValues.java index 8b85145d25c8..d37721f9a429 100644 --- 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 @@ -24,7 +24,7 @@ import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.index.NumericDocValues; import org.apache.lucene.index.SortedDocValues; -import org.apache.lucene.monitor.MonitorFields; +import org.apache.lucene.monitor.Visitors.MonitorFields; import org.apache.lucene.search.DocIdSetIterator; import org.apache.solr.common.params.CommonParams; 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 index a2bd6ae5ef57..602c532f58f2 100644 --- 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 @@ -22,8 +22,8 @@ import java.io.IOException; import java.util.Map; import org.apache.lucene.monitor.MonitorQuery; -import org.apache.lucene.monitor.QCEVisitor; 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; 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 index ef011cf9f9fb..9888474e43f7 100644 --- 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 @@ -19,7 +19,7 @@ package org.apache.solr.savedsearch; -import org.apache.lucene.monitor.MonitorFields; +import org.apache.lucene.monitor.Visitors.MonitorFields; import org.apache.solr.schema.IndexSchema; import org.apache.solr.schema.SchemaField; 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 index 2e89e0d51930..762915619dcf 100644 --- 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 @@ -30,8 +30,8 @@ import java.util.Map; import java.util.concurrent.atomic.AtomicReference; import java.util.function.BiPredicate; -import org.apache.lucene.monitor.QCEVisitor; -import org.apache.lucene.monitor.QueryTermFilterVisitor; +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; 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 index bd55c998c95b..2fd58f06f66c 100644 --- 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 @@ -19,7 +19,7 @@ package org.apache.solr.savedsearch.cache; -import org.apache.lucene.monitor.QCEVisitor; +import org.apache.lucene.monitor.Visitors.QCEVisitor; public class VersionedQueryCacheEntry { 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 index d8daecc04b8e..9933c740b0bf 100644 --- 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 @@ -34,12 +34,12 @@ import org.apache.lucene.document.Document; import org.apache.lucene.index.LeafReader; import org.apache.lucene.monitor.CandidateMatcher; -import org.apache.lucene.monitor.DocumentBatchVisitor; -import org.apache.lucene.monitor.MonitorFields; 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; 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 index 6e2c03404257..03e5fb49d7bf 100644 --- 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 @@ -22,7 +22,7 @@ import java.io.IOException; import java.util.Collection; import org.apache.lucene.index.LeafReaderContext; -import org.apache.lucene.monitor.QCEVisitor; +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; 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 index d7232c166133..74e06d499ca8 100644 --- 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 @@ -37,11 +37,11 @@ import org.apache.lucene.index.DocValuesType; import org.apache.lucene.index.IndexableField; import org.apache.lucene.index.IndexableFieldType; -import org.apache.lucene.monitor.MonitorFields; import org.apache.lucene.monitor.MonitorQuery; import org.apache.lucene.monitor.Presearcher; -import org.apache.lucene.monitor.QCEVisitor; 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; 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 index 952c531aa10c..32aa15092253 100644 --- 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 @@ -26,7 +26,7 @@ import java.nio.file.Files; import java.nio.file.Path; import java.util.List; -import org.apache.lucene.monitor.MonitorFields; +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; 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 index f9f9bd2bb88d..0ad7560207be 100644 --- 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 @@ -25,7 +25,7 @@ import java.nio.file.Path; import java.util.Locale; import java.util.stream.IntStream; -import org.apache.lucene.monitor.MonitorFields; +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; 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 index 36942debda37..96167ecb4843 100644 --- 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 @@ -19,7 +19,7 @@ package org.apache.solr.savedsearch; -import org.apache.lucene.monitor.MonitorFields; +import org.apache.lucene.monitor.Visitors.MonitorFields; import org.junit.BeforeClass; import org.junit.Test; From 858d6b2856d7f2cace73d4915fbd2182c5f22f95 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Tue, 24 Jun 2025 18:19:48 -0400 Subject: [PATCH 71/85] +mixed select -reader closing bug -QueryIndex.FIELDS reference --- .../org/apache/lucene/monitor/Visitors.java | 10 -- .../savedsearch/SavedSearchDataValues.java | 17 +- .../savedsearch/SavedSearchSchemaFields.java | 7 +- .../search/ReverseSearchComponent.java | 54 +++---- .../SavedSearchUpdateProcessorFactory.java | 14 +- .../collection1/solrconfig-single-core.xml | 10 ++ .../solr/savedsearch/SavedSearchTest.java | 145 +++++++++++++----- .../SingleCoreSavedSearchTest.java | 30 ++-- .../savedsearch/StoredSavedSearchTest.java | 3 +- 9 files changed, 185 insertions(+), 105 deletions(-) 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 index b21abfdc0271..650790731e92 100644 --- 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 @@ -25,7 +25,6 @@ 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; @@ -38,15 +37,6 @@ 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; 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 index d37721f9a429..1287cb02542e 100644 --- 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 @@ -20,16 +20,23 @@ package org.apache.solr.savedsearch; import java.io.IOException; +import java.util.Set; 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 { + public static final String QUERY_ID = "_query_id_"; + public static final String CACHE_ID = "_cache_id_"; + public static final String MONITOR_QUERY = "_mq_"; + + public static final Set REQUIRED_MONITOR_SCHEMA_FIELDS = + Set.of(QUERY_ID, CACHE_ID, MONITOR_QUERY); + private final SortedDocValues queryIdIt; private final SortedDocValues cacheIdIt; private final SortedDocValues mqIt; @@ -39,9 +46,9 @@ public class SavedSearchDataValues { 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); + cacheIdIt = reader.getSortedDocValues(CACHE_ID); + queryIdIt = reader.getSortedDocValues(QUERY_ID); + mqIt = reader.getSortedDocValues(MONITOR_QUERY); versionIt = reader.getNumericDocValues(CommonParams.VERSION_FIELD); currentDoc = DocIdSetIterator.NO_MORE_DOCS; } @@ -64,7 +71,7 @@ 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); + return reader.document(currentDoc).get(MONITOR_QUERY); } public long getVersion() throws IOException { 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 index 9888474e43f7..63e0b82a7f16 100644 --- 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 @@ -19,7 +19,6 @@ package org.apache.solr.savedsearch; -import org.apache.lucene.monitor.Visitors.MonitorFields; import org.apache.solr.schema.IndexSchema; import org.apache.solr.schema.SchemaField; @@ -30,9 +29,9 @@ public class SavedSearchSchemaFields { 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); + this.cacheId = indexSchema.getField(SavedSearchDataValues.CACHE_ID); + this.queryId = indexSchema.getField(SavedSearchDataValues.QUERY_ID); + this.monitorQuery = indexSchema.getField(SavedSearchDataValues.MONITOR_QUERY); } public SchemaField getCacheId() { 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 index 9933c740b0bf..d3768b9cbd0f 100644 --- 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 @@ -39,7 +39,6 @@ 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; @@ -52,6 +51,7 @@ 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.SavedSearchDataValues; import org.apache.solr.savedsearch.SavedSearchDecoder; import org.apache.solr.savedsearch.cache.DefaultSavedSearchCache; import org.apache.solr.savedsearch.cache.SavedSearchCache; @@ -86,12 +86,14 @@ public void init(NamedList args) { } @Override - public void prepare(ResponseBuilder rb) throws IOException { - super.prepare(rb); + public void process(ResponseBuilder rb) throws IOException { try (final DocumentBatchVisitor documentBatchVisitor = documentBatchVisitor(rb.req.getJSON(), rb.req.getSchema())) { + if (documentBatchVisitor == null) { + super.process(rb); + return; + } final LeafReader documentBatch = documentBatchVisitor.get(); - final SavedSearchCache savedSearchCache = (DefaultSavedSearchCache) rb.req.getSearcher().getCache(this.savedSearchCacheName); @@ -103,6 +105,23 @@ public void prepare(ResponseBuilder rb) throws IOException { } final Query preFilterQuery = presearcher.buildQuery(documentBatch, termAcceptor); rb.setQuery(reverseSearchQuery(preFilterQuery, rb, documentBatch, savedSearchCache)); + 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)); + } } } @@ -125,29 +144,12 @@ private static ReverseSearchQuery reverseSearchQuery( 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) { + if (json == null || !json.containsKey("params")) { + return null; + } Object jsonParams = json.get("params"); if (!(jsonParams instanceof Map)) { throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "need params"); @@ -155,7 +157,7 @@ private static DocumentBatchVisitor documentBatchVisitor( 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"); + return null; } List luceneDocs = new ArrayList<>(); for (Object document : (List) documents) { @@ -215,7 +217,7 @@ public void inform(SolrCore core) { } } - for (String fieldName : MonitorFields.REQUIRED_MONITOR_SCHEMA_FIELDS) { + for (String fieldName : SavedSearchDataValues.REQUIRED_MONITOR_SCHEMA_FIELDS) { var field = schema.getFieldOrNull(fieldName); if (field == null) { throw new IllegalStateException( 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 index 74e06d499ca8..6318ed125c92 100644 --- 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 @@ -40,7 +40,6 @@ 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; @@ -50,6 +49,7 @@ import org.apache.solr.core.SolrCore; import org.apache.solr.request.SolrQueryRequest; import org.apache.solr.response.SolrQueryResponse; +import org.apache.solr.savedsearch.SavedSearchDataValues; import org.apache.solr.savedsearch.SavedSearchSchemaFields; import org.apache.solr.savedsearch.SimpleQueryParser; import org.apache.solr.savedsearch.search.ReverseSearchComponent; @@ -103,7 +103,7 @@ public SavedSearchUpdateRequestProcessor( this.savedSearchSchemaFields = new SavedSearchSchemaFields(indexSchema); this.allowedFieldNames = Set.of( - MonitorFields.MONITOR_QUERY, + SavedSearchDataValues.MONITOR_QUERY, indexSchema.getUniqueKeyField().getName(), CommonParams.VERSION_FIELD); } @@ -113,12 +113,12 @@ 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); + var queryFieldValue = solrInputDocument.getFieldValue(SavedSearchDataValues.MONITOR_QUERY); if (queryFieldValue == null) { throw new SolrException( SolrException.ErrorCode.BAD_REQUEST, "Document is missing mandatory " - + MonitorFields.MONITOR_QUERY + + SavedSearchDataValues.MONITOR_QUERY + " field which is required by " + getClass().getSimpleName() + "."); @@ -160,7 +160,9 @@ public void processAdd(AddUpdateCommand cmd) throws IOException { solrInputDocument .getChildDocuments() .forEach( - child -> child.setField(idFieldName, child.getFieldValue(MonitorFields.CACHE_ID))); + child -> + child.setField( + idFieldName, child.getFieldValue(SavedSearchDataValues.CACHE_ID))); } copyFirstChildToParent(solrInputDocument, firstChild); super.processAdd(cmd); @@ -169,7 +171,7 @@ public void processAdd(AddUpdateCommand cmd) throws IOException { private void copyFirstChildToParent(SolrInputDocument parent, SolrInputDocument firstChild) { parent.setField( indexSchema.getUniqueKeyField().getName(), - firstChild.getFieldValue(MonitorFields.CACHE_ID)); + firstChild.getFieldValue(SavedSearchDataValues.CACHE_ID)); for (var firstChildField : firstChild) { parent.setField(firstChildField.getName(), firstChildField.getValue()); } 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 index 26a2a9d09338..833f4e15aa0f 100644 --- 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 @@ -94,6 +94,16 @@ true id + + reverseSearch + facet + facet_module + highlight + stats + debug + expand + terms + 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 index 32aa15092253..25c9a38fb20f 100644 --- 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 @@ -26,7 +26,6 @@ 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; @@ -38,18 +37,42 @@ 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(0), + SavedSearchDataValues.MONITOR_QUERY, + "content_s:\"elevator music\""); index( id, Integer.toString(1), - MonitorFields.MONITOR_QUERY, + SavedSearchDataValues.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"); + index( + id, + Integer.toString(2), + SavedSearchDataValues.MONITOR_QUERY, + "content_s:\"elevator sounds\""); + index( + id, + Integer.toString(3), + SavedSearchDataValues.MONITOR_QUERY, + "content_s:\"elevator drop\""); + index( + id, + Integer.toString(4), + SavedSearchDataValues.MONITOR_QUERY, + "content_s:\"elevator stairs\""); + index( + id, + Integer.toString(5), + SavedSearchDataValues.MONITOR_QUERY, + "other_content_s:\"solr is cool\""); + index( + id, + Integer.toString(6), + SavedSearchDataValues.MONITOR_QUERY, + "other_content_s:\"solr is lame\""); + index(id, Integer.toString(7), SavedSearchDataValues.MONITOR_QUERY, "content_s:something"); commit(); handle.clear(); handle.put("responseHeader", SKIP); @@ -58,7 +81,7 @@ public void testMonitorQuery() throws Exception { Object[] params = new Object[] { CommonParams.SORT, - MonitorFields.QUERY_ID + " desc", + SavedSearchDataValues.QUERY_ID + " desc", CommonParams.JSON, read("/monitor/doc1.json"), CommonParams.QT, @@ -72,18 +95,42 @@ public void testMonitorQuery() throws Exception { @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(0), + SavedSearchDataValues.MONITOR_QUERY, + "content_s:\"elevator music\""); index( id, Integer.toString(1), - MonitorFields.MONITOR_QUERY, + SavedSearchDataValues.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"); + index( + id, + Integer.toString(2), + SavedSearchDataValues.MONITOR_QUERY, + "content_s:\"elevator sounds\""); + index( + id, + Integer.toString(3), + SavedSearchDataValues.MONITOR_QUERY, + "content_s:\"elevator drop\""); + index( + id, + Integer.toString(4), + SavedSearchDataValues.MONITOR_QUERY, + "content_s:\"elevator stairs\""); + index( + id, + Integer.toString(5), + SavedSearchDataValues.MONITOR_QUERY, + "other_content_s:\"solr is cool\""); + index( + id, + Integer.toString(6), + SavedSearchDataValues.MONITOR_QUERY, + "other_content_s:\"solr is lame\""); + index(id, Integer.toString(7), SavedSearchDataValues.MONITOR_QUERY, "content_s:something"); commit(); handle.clear(); handle.put("responseHeader", SKIP); @@ -92,7 +139,7 @@ public void testMonitorQueryWithUpdate() throws Exception { Object[] params = new Object[] { CommonParams.SORT, - MonitorFields.QUERY_ID + " desc", + SavedSearchDataValues.QUERY_ID + " desc", CommonParams.JSON, read("/monitor/doc0.json"), CommonParams.QT, @@ -103,14 +150,22 @@ public void testMonitorQueryWithUpdate() throws Exception { 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(5), + SavedSearchDataValues.MONITOR_QUERY, + "other_content_s:\"solr is lame\""); + index( + id, + Integer.toString(6), + SavedSearchDataValues.MONITOR_QUERY, + "other_content_s:\"solr is cool\""); index( id, Integer.toString(1), - MonitorFields.MONITOR_QUERY, + SavedSearchDataValues.MONITOR_QUERY, "{!xmlparser}steep hill"); - index(id, Integer.toString(2), MonitorFields.MONITOR_QUERY, "content_s:elevator"); + index(id, Integer.toString(2), SavedSearchDataValues.MONITOR_QUERY, "content_s:elevator"); commit(); handle.clear(); handle.put("responseHeader", SKIP); @@ -131,8 +186,16 @@ public void testMonitorQueryWithUpdate() throws Exception { @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\""); + index( + id, + Integer.toString(0), + SavedSearchDataValues.MONITOR_QUERY, + "content_s:\"elevator stairs\""); + index( + id, + Integer.toString(1), + SavedSearchDataValues.MONITOR_QUERY, + "content_s:\"something else\""); commit(); handle.clear(); handle.put("responseHeader", SKIP); @@ -159,12 +222,12 @@ public void testDisjunctionQuery() throws Exception { index( id, Integer.toString(0), - MonitorFields.MONITOR_QUERY, + SavedSearchDataValues.MONITOR_QUERY, "{!xmlparser}elevatorwindastufen"); index( id, Integer.toString(1), - MonitorFields.MONITOR_QUERY, + SavedSearchDataValues.MONITOR_QUERY, "{!xmlparser}nottheseterms"); commit(); handle.clear(); @@ -191,7 +254,7 @@ public void testNoDanglingDecomposition() throws Exception { index( id, Integer.toString(0), - MonitorFields.MONITOR_QUERY, + SavedSearchDataValues.MONITOR_QUERY, "{!xmlparser}elevatorlift"); commit(); handle.clear(); @@ -215,7 +278,7 @@ public void testNoDanglingDecomposition() throws Exception { index( id, Integer.toString(0), - MonitorFields.MONITOR_QUERY, + SavedSearchDataValues.MONITOR_QUERY, "{!xmlparser}elevator"); commit(); response = query(params); @@ -228,9 +291,13 @@ public void testNotQuery() throws Exception { index( id, Integer.toString(0), - MonitorFields.MONITOR_QUERY, + SavedSearchDataValues.MONITOR_QUERY, "*:* -content0_s:\"elevator stairs\""); - index(id, Integer.toString(1), MonitorFields.MONITOR_QUERY, "*:* -content_s:\"candy canes\""); + index( + id, + Integer.toString(1), + SavedSearchDataValues.MONITOR_QUERY, + "*:* -content_s:\"candy canes\""); commit(); handle.clear(); handle.put("responseHeader", SKIP); @@ -253,11 +320,11 @@ public void testNotQuery() throws Exception { @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*"); + index(id, Integer.toString(0), SavedSearchDataValues.MONITOR_QUERY, "content_s:te*"); + index(id, Integer.toString(1), SavedSearchDataValues.MONITOR_QUERY, "content_s:tes*"); + index(id, Integer.toString(2), SavedSearchDataValues.MONITOR_QUERY, "content_s:test*"); + index(id, Integer.toString(3), SavedSearchDataValues.MONITOR_QUERY, "content_s:tex*"); + index(id, Integer.toString(4), SavedSearchDataValues.MONITOR_QUERY, "content_s:tests*"); commit(); handle.clear(); handle.put("responseHeader", SKIP); @@ -283,7 +350,7 @@ public void testDeleteByQueryId() throws Exception { index( id, Integer.toString(0), - MonitorFields.MONITOR_QUERY, + SavedSearchDataValues.MONITOR_QUERY, "{!xmlparser}elevatorlift"); commit(); handle.clear(); @@ -303,7 +370,7 @@ public void testDeleteByQueryId() throws Exception { QueryResponse response = query(params); validateDocList(response, List.of("0")); - del(MonitorFields.QUERY_ID + ":0"); + del(SavedSearchDataValues.QUERY_ID + ":0"); commit(); response = query(CommonParams.Q, "*:*"); validateDocList(response, List.of()); @@ -317,7 +384,7 @@ void validateDocList(QueryResponse response, Object expectedValue) { int i = 0; assertEquals(expectedValues.size(), actualValues.size()); for (var ev : expectedValues) { - assertEquals(ev, actualValues.get(i).getFieldValue(MonitorFields.QUERY_ID)); + assertEquals(ev, actualValues.get(i).getFieldValue(SavedSearchDataValues.QUERY_ID)); i++; } } 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 index 0ad7560207be..72356d59d249 100644 --- 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 @@ -25,7 +25,6 @@ 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; @@ -55,7 +54,7 @@ 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(adoc("id", "1", SavedSearchDataValues.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); @@ -70,8 +69,8 @@ public void coexistWithRegularDocumentsTest() throws Exception { @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(adoc("id", "1", SavedSearchDataValues.MONITOR_QUERY, "id:4"), monitorChain); + addDoc(adoc("id", "2", SavedSearchDataValues.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); @@ -91,7 +90,7 @@ public void missingQueryFieldTest() { String lowerCaseMessage = ex.getMessage().toLowerCase(Locale.ROOT); assertTrue(lowerCaseMessage.contains("missing")); assertTrue(lowerCaseMessage.contains("mandatory")); - assertTrue(ex.getMessage().contains(MonitorFields.MONITOR_QUERY)); + assertTrue(ex.getMessage().contains(SavedSearchDataValues.MONITOR_QUERY)); assertTrue(lowerCaseMessage.contains("field")); } @@ -107,7 +106,7 @@ public void unsupportedFieldTest() { adoc( "id", "1", - MonitorFields.MONITOR_QUERY, + SavedSearchDataValues.MONITOR_QUERY, "content_s:test", unsupportedField1, "a", @@ -126,14 +125,19 @@ public void unsupportedFieldTest() { public void multiPassPresearcherTest() throws Exception { addDoc( adoc( - "id", "0", MonitorFields.MONITOR_QUERY, "content0_s:\"elevator stairs and escalator\""), + "id", + "0", + SavedSearchDataValues.MONITOR_QUERY, + "content0_s:\"elevator stairs and escalator\""), monitorChain); addDoc( - adoc("id", "1", MonitorFields.MONITOR_QUERY, "content0_s:\"elevator test\""), monitorChain); + adoc("id", "1", SavedSearchDataValues.MONITOR_QUERY, "content0_s:\"elevator test\""), + monitorChain); addDoc( - adoc("id", "2", MonitorFields.MONITOR_QUERY, "content0_s:\"stairs test\""), monitorChain); + adoc("id", "2", SavedSearchDataValues.MONITOR_QUERY, "content0_s:\"stairs test\""), + monitorChain); addDoc( - adoc("id", "3", MonitorFields.MONITOR_QUERY, "content0_s:\"elevator stairs\""), + adoc("id", "3", SavedSearchDataValues.MONITOR_QUERY, "content0_s:\"elevator stairs\""), monitorChain); addDoc(commit(), monitorChain); URL url = getClass().getResource("/monitor/elevator-doc.json"); @@ -146,7 +150,7 @@ public void multiPassPresearcherTest() throws Exception { CommonParams.JSON, json, CommonParams.QT, - "/reverseSearch", + "/select", CommonParams.DEBUG_QUERY, "true" }; @@ -168,7 +172,7 @@ public void manySegmentsQuery() throws Exception { adoc( "id", Integer.toString(i), - MonitorFields.MONITOR_QUERY, + SavedSearchDataValues.MONITOR_QUERY, "content_s:\"elevator stairs\""), monitorChain); } catch (Exception e) { @@ -208,7 +212,7 @@ public void manySegmentsQuery() throws Exception { adoc( "id", Integer.toString(i), - MonitorFields.MONITOR_QUERY, + SavedSearchDataValues.MONITOR_QUERY, "content_s:\"x y\""), monitorChain); } catch (Exception e) { 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 index 96167ecb4843..fadde0447186 100644 --- 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 @@ -19,7 +19,6 @@ package org.apache.solr.savedsearch; -import org.apache.lucene.monitor.Visitors.MonitorFields; import org.junit.BeforeClass; import org.junit.Test; @@ -35,7 +34,7 @@ public void indexBigQueryTest() throws Exception { index( id, Integer.toString(0), - MonitorFields.MONITOR_QUERY, + SavedSearchDataValues.MONITOR_QUERY, "{!xmlparser}" + read("/monitor/BigDisjunctionQuery.xml")); commit(); } From 9b48a7f278589761e18dfbd0ce48683f0354d646 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Wed, 25 Jun 2025 22:16:43 -0400 Subject: [PATCH 72/85] add test to detect AlreadyClosedException --- .../SingleCoreSavedSearchTest.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) 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 index 72356d59d249..7ba45ed3df76 100644 --- 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 @@ -227,4 +227,24 @@ public void manySegmentsQuery() throws Exception { + count / 2 + "'"); } + + @Test + public void fieldExistsQuery() throws Exception { + // FieldExistsQuery checks if the ephemeral single-doc index is open. + // This was a bug that flew under the radar because not a lot of places in + // Lucene check if the LeafReader is still open. + addDoc( + adoc("id", String.valueOf(1), SavedSearchDataValues.MONITOR_QUERY, "id:[* TO *]"), + 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']"); + } } From 42fa246a128114d4a1422e32c45fcab2752d99ab Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Thu, 26 Jun 2025 12:45:33 -0400 Subject: [PATCH 73/85] initialize cache on start-up --- .../solr/savedsearch/cache/DefaultSavedSearchCache.java | 5 +++++ 1 file changed, 5 insertions(+) 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 index 762915619dcf..67478b90c994 100644 --- 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 @@ -258,6 +258,11 @@ public void initializeMetrics(SolrMetricsContext parentContext, String scope) { solrMetricsContext.gauge(cacheMap, true, scope, getCategory().toString()); } + @Override + public void initialSearcher(SolrIndexSearcher initialSearcher) { + warm(initialSearcher, this); + } + public int getInitialSize() { return initialSize; } From ed27b2275ca3ac8d03f5a9b503a4437d2e6cc979 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 27 Jun 2025 18:26:59 -0400 Subject: [PATCH 74/85] remove cache_id and QCEVisitor --- .../org/apache/lucene/monitor/Visitors.java | 41 ------------- .../savedsearch/SavedSearchDataValues.java | 58 +++++++++++++++++-- .../solr/savedsearch/SavedSearchDecoder.java | 8 +-- .../savedsearch/SavedSearchSchemaFields.java | 48 --------------- .../cache/DefaultSavedSearchCache.java | 4 +- .../cache/SavedSearchLatestRegenerator.java | 7 ++- .../cache/VersionedQueryCacheEntry.java | 6 +- .../search/ReverseSearchComponent.java | 5 +- .../search/ReverseSearchQuery.java | 12 ++-- .../SavedSearchUpdateProcessorFactory.java | 43 +++++--------- 10 files changed, 92 insertions(+), 140 deletions(-) delete mode 100644 solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchSchemaFields.java 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 index 650790731e92..9242c54e6178 100644 --- 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 @@ -22,9 +22,7 @@ package org.apache.lucene.monitor; import java.io.IOException; -import java.util.ArrayList; import java.util.List; -import java.util.Map; import java.util.function.BiPredicate; import java.util.function.Supplier; import java.util.stream.Collectors; @@ -32,7 +30,6 @@ 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 { @@ -85,42 +82,4 @@ 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/SavedSearchDataValues.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchDataValues.java index 1287cb02542e..e53e37ce3519 100644 --- 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 @@ -20,22 +20,26 @@ package org.apache.solr.savedsearch; import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; import java.util.Set; 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.MonitorQuery; +import org.apache.lucene.monitor.QueryDecomposer; import org.apache.lucene.search.DocIdSetIterator; +import org.apache.lucene.search.Query; import org.apache.solr.common.params.CommonParams; public class SavedSearchDataValues { public static final String QUERY_ID = "_query_id_"; - public static final String CACHE_ID = "_cache_id_"; public static final String MONITOR_QUERY = "_mq_"; - public static final Set REQUIRED_MONITOR_SCHEMA_FIELDS = - Set.of(QUERY_ID, CACHE_ID, MONITOR_QUERY); + public static final Set REQUIRED_MONITOR_SCHEMA_FIELDS = Set.of(QUERY_ID, MONITOR_QUERY); private final SortedDocValues queryIdIt; private final SortedDocValues cacheIdIt; @@ -44,9 +48,9 @@ public class SavedSearchDataValues { private final LeafReader reader; private int currentDoc; - public SavedSearchDataValues(LeafReaderContext context) throws IOException { + public SavedSearchDataValues(LeafReaderContext context, String idFieldName) throws IOException { reader = context.reader(); - cacheIdIt = reader.getSortedDocValues(CACHE_ID); + cacheIdIt = reader.getSortedDocValues(idFieldName); queryIdIt = reader.getSortedDocValues(QUERY_ID); mqIt = reader.getSortedDocValues(MONITOR_QUERY); versionIt = reader.getNumericDocValues(CommonParams.VERSION_FIELD); @@ -80,4 +84,48 @@ public long getVersion() throws IOException { } return 0; } + + public static class QueryDisjunct { + + private final String disjunctId; + private final String queryId; + private final Query matchQuery; + private final Map metadata; + + private QueryDisjunct( + String disjunctId, String queryId, Query matchQuery, Map metadata) { + this.disjunctId = disjunctId; + this.queryId = queryId; + this.matchQuery = matchQuery; + this.metadata = metadata; + } + + public static List decompose(MonitorQuery mq, QueryDecomposer decomposer) { + int upto = 0; + List disjuncts = new ArrayList<>(); + for (var disjunct : decomposer.decompose(mq.getQuery())) { + String suffix = upto == 0 ? "" : "_" + upto; + disjuncts.add( + new QueryDisjunct(mq.getId() + suffix, mq.getId(), disjunct, mq.getMetadata())); + upto++; + } + return disjuncts; + } + + public Query getMatchQuery() { + return matchQuery; + } + + public String getId() { + return disjunctId; + } + + public String getQueryId() { + return queryId; + } + + public Map getMetadata() { + return metadata; + } + } } 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 index 602c532f58f2..ce029a03c752 100644 --- 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 @@ -23,8 +23,8 @@ 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.SavedSearchDataValues.QueryDisjunct; import org.apache.solr.savedsearch.search.ReverseSearchComponent; public class SavedSearchDecoder { @@ -47,10 +47,10 @@ private MonitorQuery decode(SavedSearchDataValues savedSearchDataValues) throws return new MonitorQuery(id, query, queryStr, Map.of()); } - public QCEVisitor getComponent(SavedSearchDataValues dataValues, String cacheId) + public QueryDisjunct getComponent(SavedSearchDataValues dataValues, String cacheId) throws IOException { - for (QCEVisitor qce : QCEVisitor.decompose(decode(dataValues), queryDecomposer)) { - if (qce.getCacheId().equals(cacheId)) { + for (QueryDisjunct qce : QueryDisjunct.decompose(decode(dataValues), queryDecomposer)) { + if (qce.getId().equals(cacheId)) { return qce; } } 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 deleted file mode 100644 index 63e0b82a7f16..000000000000 --- a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchSchemaFields.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * - * * 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.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(SavedSearchDataValues.CACHE_ID); - this.queryId = indexSchema.getField(SavedSearchDataValues.QUERY_ID); - this.monitorQuery = indexSchema.getField(SavedSearchDataValues.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/cache/DefaultSavedSearchCache.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/DefaultSavedSearchCache.java index 67478b90c994..349fa4483e0a 100644 --- 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 @@ -30,7 +30,6 @@ 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; @@ -39,6 +38,7 @@ import org.apache.solr.metrics.MetricsMap; import org.apache.solr.metrics.SolrMetricsContext; import org.apache.solr.savedsearch.SavedSearchDataValues; +import org.apache.solr.savedsearch.SavedSearchDataValues.QueryDisjunct; import org.apache.solr.savedsearch.SavedSearchDecoder; import org.apache.solr.search.CacheRegenerator; import org.apache.solr.search.SolrCache; @@ -284,7 +284,7 @@ private VersionedQueryCacheEntry compute( try { var version = dataValues.getVersion(); if (prevEntry == null || version > prevEntry.version) { - QCEVisitor component = decoder.getComponent(dataValues, cacheId); + QueryDisjunct component = decoder.getComponent(dataValues, cacheId); currentStats.updateAndGet(CurrentStats::miss); return new VersionedQueryCacheEntry(component, version); } 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 index 71655001129e..33c1d06016b0 100644 --- 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 @@ -25,6 +25,7 @@ import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; import org.apache.solr.common.params.CommonParams; +import org.apache.solr.core.SolrCore; import org.apache.solr.savedsearch.SavedSearchDataValues; import org.apache.solr.savedsearch.SavedSearchDecoder; import org.apache.solr.search.CacheRegenerator; @@ -57,11 +58,13 @@ public boolean regenerateItem( .search(versionRangeQuery(cache), batchSize) .scoreDocs; int batchesRemaining = cache.getInitialSize() / batchSize - 1; - SavedSearchDecoder decoder = new SavedSearchDecoder(searcher.getCore()); + SolrCore core = searcher.getCore(); + SavedSearchDecoder decoder = new SavedSearchDecoder(core); while (topDocs.length > 0 && batchesRemaining > 0) { int docIndex = 0; for (LeafReaderContext ctx : reader.leaves()) { - SavedSearchDataValues dataValues = new SavedSearchDataValues(ctx); + SavedSearchDataValues dataValues = + new SavedSearchDataValues(ctx, core.getLatestSchema().getUniqueKeyField().getName()); int shiftedMax = ctx.reader().maxDoc() + ctx.docBase; while (docIndex < topDocs.length && topDocs[docIndex].doc >= ctx.docBase 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 index 2fd58f06f66c..4e7762569db6 100644 --- 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 @@ -19,14 +19,14 @@ package org.apache.solr.savedsearch.cache; -import org.apache.lucene.monitor.Visitors.QCEVisitor; +import org.apache.solr.savedsearch.SavedSearchDataValues.QueryDisjunct; public class VersionedQueryCacheEntry { - public final QCEVisitor entry; + public final QueryDisjunct entry; public final long version; - public VersionedQueryCacheEntry(QCEVisitor entry, long version) { + public VersionedQueryCacheEntry(QueryDisjunct entry, long version) { this.entry = entry; this.version = version; } 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 index d3768b9cbd0f..2a41ff8eb1db 100644 --- 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 @@ -139,7 +139,10 @@ private static ReverseSearchQuery reverseSearchQuery( final ReverseSearchQuery.ReverseSearchContext context = new ReverseSearchQuery.ReverseSearchContext( - savedSearchCache, savedSearchDecoder, solrMatcherSink); + savedSearchCache, + savedSearchDecoder, + solrMatcherSink, + rb.req.getSchema().getUniqueKeyField().getName()); return new ReverseSearchQuery(context, preFilterQuery); } 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 index 03e5fb49d7bf..6a4873c4286a 100644 --- 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 @@ -22,7 +22,6 @@ 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; @@ -37,6 +36,7 @@ import org.apache.lucene.search.TwoPhaseIterator; import org.apache.lucene.search.Weight; import org.apache.solr.savedsearch.SavedSearchDataValues; +import org.apache.solr.savedsearch.SavedSearchDataValues.QueryDisjunct; import org.apache.solr.savedsearch.SavedSearchDecoder; import org.apache.solr.savedsearch.cache.SavedSearchCache; @@ -178,7 +178,8 @@ static class ReverseSearchScorer extends Scorer { this.matcherSink = reverseSearchContext.solrMatcherSink; this.metadata = new Metadata(); matcherSink.captureMetadata(metadata); - this.dataValues = new SavedSearchDataValues(leafReaderContext); + this.dataValues = + new SavedSearchDataValues(leafReaderContext, reverseSearchContext.idFieldName); } @Override @@ -252,7 +253,7 @@ public boolean matches() throws IOException { return false; } - private QCEVisitor getEntry(SavedSearchDataValues dataValues) throws IOException { + private QueryDisjunct getEntry(SavedSearchDataValues dataValues) throws IOException { var versionedEntry = savedSearchCache == null ? null @@ -275,14 +276,17 @@ static class ReverseSearchContext { private final SavedSearchCache queryCache; private final SavedSearchDecoder queryDecoder; private final SolrMatcherSink solrMatcherSink; + private final String idFieldName; ReverseSearchContext( SavedSearchCache queryCache, SavedSearchDecoder queryDecoder, - SolrMatcherSink solrMatcherSink) { + SolrMatcherSink solrMatcherSink, + String idFieldName) { this.queryCache = queryCache; this.queryDecoder = queryDecoder; this.solrMatcherSink = solrMatcherSink; + this.idFieldName = idFieldName; } } 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 index 6318ed125c92..0103e2049316 100644 --- 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 @@ -40,7 +40,6 @@ import org.apache.lucene.monitor.MonitorQuery; import org.apache.lucene.monitor.Presearcher; import org.apache.lucene.monitor.QueryDecomposer; -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; @@ -50,7 +49,7 @@ import org.apache.solr.request.SolrQueryRequest; import org.apache.solr.response.SolrQueryResponse; import org.apache.solr.savedsearch.SavedSearchDataValues; -import org.apache.solr.savedsearch.SavedSearchSchemaFields; +import org.apache.solr.savedsearch.SavedSearchDataValues.QueryDisjunct; import org.apache.solr.savedsearch.SimpleQueryParser; import org.apache.solr.savedsearch.search.ReverseSearchComponent; import org.apache.solr.schema.IndexSchema; @@ -87,8 +86,9 @@ static class SavedSearchUpdateRequestProcessor extends UpdateRequestProcessor { private final IndexSchema indexSchema; private final QueryDecomposer queryDecomposer; private final Presearcher presearcher; - private final SavedSearchSchemaFields savedSearchSchemaFields; private final Set allowedFieldNames; + private final SchemaField queryIdField; + private final SchemaField monitorQueryField; public SavedSearchUpdateRequestProcessor( UpdateRequestProcessor next, @@ -100,7 +100,8 @@ public SavedSearchUpdateRequestProcessor( this.indexSchema = core.getLatestSchema(); this.queryDecomposer = queryDecomposer; this.presearcher = presearcher; - this.savedSearchSchemaFields = new SavedSearchSchemaFields(indexSchema); + this.queryIdField = indexSchema.getField(SavedSearchDataValues.QUERY_ID); + this.monitorQueryField = indexSchema.getField(SavedSearchDataValues.MONITOR_QUERY); this.allowedFieldNames = Set.of( SavedSearchDataValues.MONITOR_QUERY, @@ -156,39 +157,21 @@ public void processAdd(AddUpdateCommand cmd) throws IOException { solrInputDocument.getChildDocuments().clear(); } solrInputDocument.addChildDocuments(children.stream().skip(1).collect(Collectors.toList())); - if (solrInputDocument.hasChildDocuments()) { - solrInputDocument - .getChildDocuments() - .forEach( - child -> - child.setField( - idFieldName, child.getFieldValue(SavedSearchDataValues.CACHE_ID))); - } - copyFirstChildToParent(solrInputDocument, firstChild); - super.processAdd(cmd); - } - - private void copyFirstChildToParent(SolrInputDocument parent, SolrInputDocument firstChild) { - parent.setField( - indexSchema.getUniqueKeyField().getName(), - firstChild.getFieldValue(SavedSearchDataValues.CACHE_ID)); for (var firstChildField : firstChild) { - parent.setField(firstChildField.getName(), firstChildField.getValue()); + solrInputDocument.setField(firstChildField.getName(), firstChildField.getValue()); } + super.processAdd(cmd); } private Stream decompose(MonitorQuery monitorQuery) { - return QCEVisitor.decompose(monitorQuery, queryDecomposer).stream() + return QueryDisjunct.decompose(monitorQuery, queryDecomposer).stream() .map( - qce -> { + disjunct -> { 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())); + presearcher.indexQuery(disjunct.getMatchQuery(), monitorQuery.getMetadata()); + doc.add(indexSchema.getUniqueKeyField().createField(disjunct.getId())); + doc.add(queryIdField.createField(disjunct.getQueryId())); + doc.add(monitorQueryField.createField(monitorQuery.getQueryString())); return doc; }); } From 36eb409008f8254059607f08bc1351cba16e907f Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 27 Jun 2025 18:34:35 -0400 Subject: [PATCH 75/85] move VersionedQueryCacheEntry.java to SavedSearchCache --- .../cache/DefaultSavedSearchCache.java | 1 + .../savedsearch/cache/SavedSearchCache.java | 11 +++++++ .../cache/VersionedQueryCacheEntry.java | 33 ------------------- 3 files changed, 12 insertions(+), 33 deletions(-) delete mode 100644 solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/VersionedQueryCacheEntry.java 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 index 349fa4483e0a..d447ebc12f8b 100644 --- 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 @@ -45,6 +45,7 @@ import org.apache.solr.search.SolrCacheBase; import org.apache.solr.search.SolrIndexSearcher; import org.apache.solr.util.IOFunction; +import org.apache.solr.savedsearch.cache.SavedSearchCache.VersionedQueryCacheEntry; public class DefaultSavedSearchCache extends SolrCacheBase implements SolrCache, 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 index 32208f47172d..777ac5512488 100644 --- 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 @@ -30,4 +30,15 @@ VersionedQueryCacheEntry computeIfStale( SavedSearchDataValues dataValues, SavedSearchDecoder decoder) throws IOException; boolean acceptTerm(String field, BytesRef value); + + class VersionedQueryCacheEntry { + + public final SavedSearchDataValues.QueryDisjunct entry; + public final long version; + + VersionedQueryCacheEntry(SavedSearchDataValues.QueryDisjunct entry, long version) { + this.entry = entry; + this.version = version; + } + } } 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 deleted file mode 100644 index 4e7762569db6..000000000000 --- a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/VersionedQueryCacheEntry.java +++ /dev/null @@ -1,33 +0,0 @@ -/* - * - * * 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.solr.savedsearch.SavedSearchDataValues.QueryDisjunct; - -public class VersionedQueryCacheEntry { - - public final QueryDisjunct entry; - public final long version; - - public VersionedQueryCacheEntry(QueryDisjunct entry, long version) { - this.entry = entry; - this.version = version; - } -} From 180d8217adde2529f60d11e0170cd7a3182dc283 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 27 Jun 2025 18:34:57 -0400 Subject: [PATCH 76/85] move VersionedQueryCacheEntry.java to SavedSearchCache --- .../src/test-files/solr/collection1/schema-aliasing.xml | 2 -- .../src/test-files/solr/collection1/schema-stored-mq.xml | 2 -- .../saved-search/src/test-files/solr/collection1/schema.xml | 2 -- 3 files changed, 6 deletions(-) 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 index 10d2e55deaf3..a7fec147ff1b 100644 --- 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 @@ -91,8 +91,6 @@ - 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 index 734afc91a882..2cd3d925a5f1 100644 --- 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 @@ -89,8 +89,6 @@ - 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 index 0aae08b7c014..49e9135e5e11 100644 --- a/solr/modules/saved-search/src/test-files/solr/collection1/schema.xml +++ b/solr/modules/saved-search/src/test-files/solr/collection1/schema.xml @@ -89,8 +89,6 @@ - From 9d3c63da80f5262e70529f9df69c2406cd5416e2 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 27 Jun 2025 18:40:48 -0400 Subject: [PATCH 77/85] move regenerator into DefaultSavedSearchCache --- .../cache/DefaultSavedSearchCache.java | 71 +++++++++++++- .../cache/SavedSearchLatestRegenerator.java | 96 ------------------- .../collection1/solrconfig-single-core.xml | 2 +- .../solr/collection1/solrconfig.xml | 2 +- 4 files changed, 72 insertions(+), 99 deletions(-) delete mode 100644 solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SavedSearchLatestRegenerator.java 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 index d447ebc12f8b..89ca9611911a 100644 --- 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 @@ -30,22 +30,28 @@ import java.util.Map; import java.util.concurrent.atomic.AtomicReference; import java.util.function.BiPredicate; +import org.apache.lucene.document.LongPoint; +import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.monitor.Visitors.QueryTermFilterVisitor; +import org.apache.lucene.search.IndexSearcher; +import org.apache.lucene.search.Query; 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.common.params.CommonParams; +import org.apache.solr.core.SolrCore; import org.apache.solr.metrics.MetricsMap; import org.apache.solr.metrics.SolrMetricsContext; import org.apache.solr.savedsearch.SavedSearchDataValues; import org.apache.solr.savedsearch.SavedSearchDataValues.QueryDisjunct; import org.apache.solr.savedsearch.SavedSearchDecoder; +import org.apache.solr.savedsearch.cache.SavedSearchCache.VersionedQueryCacheEntry; 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; -import org.apache.solr.savedsearch.cache.SavedSearchCache.VersionedQueryCacheEntry; public class DefaultSavedSearchCache extends SolrCacheBase implements SolrCache, @@ -327,4 +333,67 @@ private static CurrentStats miss(CurrentStats old) { return new CurrentStats(old.hits, old.lookups + 1); } } + + public static 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; + SolrCore core = searcher.getCore(); + SavedSearchDecoder decoder = new SavedSearchDecoder(core); + while (topDocs.length > 0 && batchesRemaining > 0) { + int docIndex = 0; + for (LeafReaderContext ctx : reader.leaves()) { + SavedSearchDataValues dataValues = + new SavedSearchDataValues(ctx, core.getLatestSchema().getUniqueKeyField().getName()); + 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/SavedSearchLatestRegenerator.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SavedSearchLatestRegenerator.java deleted file mode 100644 index 33c1d06016b0..000000000000 --- a/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/cache/SavedSearchLatestRegenerator.java +++ /dev/null @@ -1,96 +0,0 @@ -/* - * - * * 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.core.SolrCore; -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; - SolrCore core = searcher.getCore(); - SavedSearchDecoder decoder = new SavedSearchDecoder(core); - while (topDocs.length > 0 && batchesRemaining > 0) { - int docIndex = 0; - for (LeafReaderContext ctx : reader.leaves()) { - SavedSearchDataValues dataValues = - new SavedSearchDataValues(ctx, core.getLatestSchema().getUniqueKeyField().getName()); - 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/test-files/solr/collection1/solrconfig-single-core.xml b/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig-single-core.xml index 833f4e15aa0f..d69a45ef1b04 100644 --- 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 @@ -69,7 +69,7 @@ class="solr.DefaultSavedSearchCache" async="false" maxRamMB="1" - regenerator="solr.SavedSearchLatestRegenerator"/> + regenerator="solr.DefaultSavedSearchCache$SavedSearchLatestRegenerator"/> true 20 200 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 index c5fb6fbd90ea..a42de8b0e5c1 100644 --- a/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig.xml +++ b/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig.xml @@ -68,7 +68,7 @@ true From 4d9542ba83a225ef4c4b423aa484ec1c1c9f69eb Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 27 Jun 2025 22:45:47 -0400 Subject: [PATCH 78/85] small refactor --- .../solr/savedsearch/SavedSearchDecoder.java | 2 +- .../cache/DefaultSavedSearchCache.java | 16 ++++++++-------- .../solr/savedsearch/cache/SavedSearchCache.java | 3 ++- .../search/ReverseSearchComponent.java | 11 +++++------ .../savedsearch/search/ReverseSearchQuery.java | 2 +- .../solr/collection1/solrconfig-single-core.xml | 2 +- .../test-files/solr/collection1/solrconfig.xml | 2 +- 7 files changed, 19 insertions(+), 19 deletions(-) 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 index ce029a03c752..7ddf688d8fa2 100644 --- 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 @@ -47,7 +47,7 @@ private MonitorQuery decode(SavedSearchDataValues savedSearchDataValues) throws return new MonitorQuery(id, query, queryStr, Map.of()); } - public QueryDisjunct getComponent(SavedSearchDataValues dataValues, String cacheId) + public QueryDisjunct getDisjunct(SavedSearchDataValues dataValues, String cacheId) throws IOException { for (QueryDisjunct qce : QueryDisjunct.decompose(decode(dataValues), queryDecomposer)) { if (qce.getId().equals(cacheId)) { 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 index 89ca9611911a..868051f2e402 100644 --- 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 @@ -64,7 +64,7 @@ public class DefaultSavedSearchCache extends SolrCacheBase new AtomicReference<>(CurrentStats.init()); private Cache mqCache; - BiPredicate termAcceptor = (__, ___) -> true; + private volatile BiPredicate termFilter = (__, ___) -> true; private SolrMetricsContext solrMetricsContext; private long generationTimeMs; @@ -73,9 +73,9 @@ public class DefaultSavedSearchCache extends SolrCacheBase private long cumulativeGenerationTimeMs; private long cumulativeDocVisits; - long docVisits; + private long docVisits; // only needs to be an approximation - long versionHighWaterMark = START_HIGH_WATER_MARK; + private long versionHighWaterMark = START_HIGH_WATER_MARK; private int initialSize; private int maxSize; private int maxRamMB; @@ -90,8 +90,8 @@ public VersionedQueryCacheEntry computeIfStale( } @Override - public boolean acceptTerm(String field, BytesRef value) { - return termAcceptor.test(field, value); + public BiPredicate termFilter() { + return termFilter; } private Map mqCacheMap() { @@ -191,7 +191,7 @@ public void warm(SolrIndexSearcher searcher, SolrCache prevEntry.version) { - QueryDisjunct component = decoder.getComponent(dataValues, cacheId); + QueryDisjunct component = decoder.getDisjunct(dataValues, cacheId); currentStats.updateAndGet(CurrentStats::miss); return new VersionedQueryCacheEntry(component, version); } @@ -334,7 +334,7 @@ private static CurrentStats miss(CurrentStats old) { } } - public static class SavedSearchLatestRegenerator implements CacheRegenerator { + public static class LatestRegenerator implements CacheRegenerator { private static final int MAX_BATCH_SIZE = 1 << 10; 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 index 777ac5512488..31ef8e9aaf2e 100644 --- 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 @@ -20,6 +20,7 @@ package org.apache.solr.savedsearch.cache; import java.io.IOException; +import java.util.function.BiPredicate; import org.apache.lucene.util.BytesRef; import org.apache.solr.savedsearch.SavedSearchDataValues; import org.apache.solr.savedsearch.SavedSearchDecoder; @@ -29,7 +30,7 @@ public interface SavedSearchCache { VersionedQueryCacheEntry computeIfStale( SavedSearchDataValues dataValues, SavedSearchDecoder decoder) throws IOException; - boolean acceptTerm(String field, BytesRef value); + BiPredicate termFilter(); class VersionedQueryCacheEntry { 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 index 2a41ff8eb1db..ed340bea0bd0 100644 --- 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 @@ -27,6 +27,7 @@ import java.util.Comparator; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; import java.util.function.BiPredicate; @@ -97,12 +98,10 @@ public void process(ResponseBuilder rb) throws IOException { final SavedSearchCache savedSearchCache = (DefaultSavedSearchCache) rb.req.getSearcher().getCache(this.savedSearchCacheName); - final BiPredicate termAcceptor; - if (savedSearchCache == null) { - termAcceptor = (__, ___) -> true; - } else { - termAcceptor = savedSearchCache::acceptTerm; - } + final BiPredicate termAcceptor = + Optional.ofNullable(savedSearchCache) + .map(SavedSearchCache::termFilter) + .orElse((__, ___) -> true); final Query preFilterQuery = presearcher.buildQuery(documentBatch, termAcceptor); rb.setQuery(reverseSearchQuery(preFilterQuery, rb, documentBatch, savedSearchCache)); super.process(rb); 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 index 6a4873c4286a..9c2aaa355429 100644 --- 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 @@ -259,7 +259,7 @@ private QueryDisjunct getEntry(SavedSearchDataValues dataValues) throws IOExcept ? null : savedSearchCache.computeIfStale(dataValues, queryDecoder); return (versionedEntry == null || versionedEntry.version != dataValues.getVersion()) - ? queryDecoder.getComponent(dataValues, dataValues.getCacheId()) + ? queryDecoder.getDisjunct(dataValues, dataValues.getCacheId()) : versionedEntry.entry; } 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 index d69a45ef1b04..fe692d246cad 100644 --- 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 @@ -69,7 +69,7 @@ class="solr.DefaultSavedSearchCache" async="false" maxRamMB="1" - regenerator="solr.DefaultSavedSearchCache$SavedSearchLatestRegenerator"/> + regenerator="solr.DefaultSavedSearchCache$LatestRegenerator"/> true 20 200 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 index a42de8b0e5c1..f5ef655170cd 100644 --- a/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig.xml +++ b/solr/modules/saved-search/src/test-files/solr/collection1/solrconfig.xml @@ -68,7 +68,7 @@ true From 3a3bdc8c68c09039dcc6505fc54b4fff55010754 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Fri, 27 Jun 2025 22:54:41 -0400 Subject: [PATCH 79/85] stop stashing solrMatcherSink in context for no reason --- .../search/ReverseSearchComponent.java | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-) 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 index ed340bea0bd0..a30e3f981880 100644 --- 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 @@ -103,11 +103,12 @@ public void process(ResponseBuilder rb) throws IOException { .map(SavedSearchCache::termFilter) .orElse((__, ___) -> true); final Query preFilterQuery = presearcher.buildQuery(documentBatch, termAcceptor); - rb.setQuery(reverseSearchQuery(preFilterQuery, rb, documentBatch, savedSearchCache)); + final SolrMatcherSink solrMatcherSink = + new DefaultSolrMatcherSink<>( + QueryMatch.SIMPLE_MATCHER::createMatcher, new IndexSearcher(documentBatch)); + rb.setQuery(reverseSearchQuery(preFilterQuery, rb, solrMatcherSink, savedSearchCache)); super.process(rb); - SolrMatcherSink solrMatcherSink = - (SolrMatcherSink) rb.req.getContext().get(SolrMatcherSink.class.getSimpleName()); - if (rb.isDebug() && solrMatcherSink != null) { + if (rb.isDebug()) { ReverseSearchQuery.Metadata metadata = solrMatcherSink.getMetadata(); DebugComponent.CustomDebugInfoSources debugInfoSources = (DebugComponent.CustomDebugInfoSources) @@ -127,15 +128,9 @@ public void process(ResponseBuilder rb) throws IOException { private static ReverseSearchQuery reverseSearchQuery( Query preFilterQuery, ResponseBuilder rb, - LeafReader documentBatch, + SolrMatcherSink solrMatcherSink, 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, From f6589a7f2551939ad4e829a24b2258155070cea3 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Sat, 23 Aug 2025 15:07:55 -0400 Subject: [PATCH 80/85] don't skip docs during cache regeneration --- .../cache/DefaultSavedSearchCache.java | 86 ++++++++++++------- 1 file changed, 55 insertions(+), 31 deletions(-) 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 index 868051f2e402..a47ecf8b0aa5 100644 --- 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 @@ -27,6 +27,7 @@ import com.github.benmanes.caffeine.cache.RemovalListener; import java.io.IOException; import java.time.Duration; +import java.util.Arrays; import java.util.Map; import java.util.concurrent.atomic.AtomicReference; import java.util.function.BiPredicate; @@ -35,6 +36,9 @@ import org.apache.lucene.monitor.Visitors.QueryTermFilterVisitor; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; +import org.apache.lucene.search.ScoreDoc; +import org.apache.lucene.search.Sort; +import org.apache.lucene.search.SortField; import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.RamUsageEstimator; import org.apache.solr.common.SolrException; @@ -79,6 +83,7 @@ public class DefaultSavedSearchCache extends SolrCacheBase private int initialSize; private int maxSize; private int maxRamMB; + private int initialRamMB; @Override public VersionedQueryCacheEntry computeIfStale( @@ -106,21 +111,31 @@ public Object init(Map args, Object persistence, CacheRegenerato 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); + initialSize = Math.min((str == null) ? maxSize : Integer.parseInt(str), maxSize); + str = args.get("initialRamMB"); + initialRamMB = Math.min((str == null) ? maxRamMB : Integer.parseInt(str), maxRamMB); str = args.get(MAX_IDLE_TIME_PARAM); int maxIdleTimeSec = -1; if (str != null) { maxIdleTimeSec = Integer.parseInt(str); } - mqCache = buildCache(maxIdleTimeSec); + str = args.get("expireAfterWriteSeconds"); + int expireAfterWriteSeconds = -1; + if (str != null) { + expireAfterWriteSeconds = Integer.parseInt(str); + } + mqCache = buildCache(maxIdleTimeSec, expireAfterWriteSeconds); return persistence; } - private Cache buildCache(int maxIdleTimeSec) { + private Cache buildCache( + int maxIdleTimeSec, int expireAfterWriteSeconds) { Caffeine builder = Caffeine.newBuilder().initialCapacity(initialSize).removalListener(this).recordStats(); if (maxIdleTimeSec > 0) { builder.expireAfterAccess(Duration.ofSeconds(maxIdleTimeSec)); + } else if (expireAfterWriteSeconds > 0) { + builder.expireAfterWrite(Duration.ofSeconds(expireAfterWriteSeconds)); } if (maxRamMB >= 0) { @@ -337,6 +352,8 @@ private static CurrentStats miss(CurrentStats old) { public static class LatestRegenerator implements CacheRegenerator { private static final int MAX_BATCH_SIZE = 1 << 10; + private static final Sort VERSION_SORT = + new Sort(new SortField(CommonParams.VERSION_FIELD, SortField.Type.LONG)); @Override public boolean regenerateItem( @@ -355,45 +372,52 @@ public boolean regenerateItem( 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; + boolean isDone = false; + int countBasedBatches = cache.getInitialSize() / batchSize - 1; + long targetInitialRam = ((DefaultSavedSearchCache) newCache).initialRamMB * 1024L * 1024L; + long estimatedWeight = 0; SolrCore core = searcher.getCore(); SavedSearchDecoder decoder = new SavedSearchDecoder(core); - while (topDocs.length > 0 && batchesRemaining > 0) { - int docIndex = 0; - for (LeafReaderContext ctx : reader.leaves()) { + long maxEncounteredVersion = cache.versionHighWaterMark; + for (LeafReaderContext ctx : reader.leaves()) { + var topDocs = + new IndexSearcher(ctx.reader()) + .search(versionRangeQuery(cache.versionHighWaterMark), batchSize, VERSION_SORT) + .scoreDocs; + Arrays.sort(topDocs, (a, b) -> Long.compare(b.doc, a.doc)); + long maxLeafVersion = -1; + while (topDocs.length > 0 && !isDone) { SavedSearchDataValues dataValues = new SavedSearchDataValues(ctx, core.getLatestSchema().getUniqueKeyField().getName()); - 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); + for (ScoreDoc topDoc : topDocs) { + if (dataValues.advanceTo(topDoc.doc)) { + var cacheEntry = cache.computeIfStale(dataValues, decoder); + estimatedWeight += RamUsageEstimator.sizeOf(cacheEntry.entry.getMatchQuery()); + estimatedWeight += RamUsageEstimator.sizeOf(cacheEntry.entry.getId()); + long version = dataValues.getVersion(); + maxEncounteredVersion = Math.max(maxEncounteredVersion, version); + maxLeafVersion = Math.max(maxLeafVersion, version); + cache.docVisits++; } - cache.versionHighWaterMark = - Math.max(cache.versionHighWaterMark, dataValues.getVersion()); - cache.docVisits++; + } + topDocs = + new IndexSearcher(ctx.reader()) + .search(versionRangeQuery(maxLeafVersion + 1), batchSize, VERSION_SORT) + .scoreDocs; + Arrays.sort(topDocs, (a, b) -> Long.compare(b.doc, a.doc)); + if (targetInitialRam > 0L) { + isDone = estimatedWeight >= targetInitialRam; + } else { + isDone = --countBasedBatches <= 0; } } - var scoreDoc = topDocs[topDocs.length - 1]; - topDocs = - new IndexSearcher(searcher.getTopReaderContext()) - .searchAfter(scoreDoc, versionRangeQuery(cache), batchSize) - .scoreDocs; - batchesRemaining--; } + cache.versionHighWaterMark = Math.max(cache.versionHighWaterMark, maxEncounteredVersion); return false; } - private static Query versionRangeQuery(DefaultSavedSearchCache cache) { - return LongPoint.newRangeQuery( - CommonParams.VERSION_FIELD, cache.versionHighWaterMark, Long.MAX_VALUE); + private static Query versionRangeQuery(long version) { + return LongPoint.newRangeQuery(CommonParams.VERSION_FIELD, version, Long.MAX_VALUE); } } } From 0fc2b1f1e9d5936f443e74d06ede6e286eda4c01 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Thu, 4 Sep 2025 16:44:40 -0400 Subject: [PATCH 81/85] merge main + minor cache tweak --- .../lucene/monitor/CandidateMatcher.java | 125 ------------------ .../savedsearch/SavedSearchDataValues.java | 2 +- .../cache/DefaultSavedSearchCache.java | 12 +- .../search/ReverseSearchQuery.java | 26 +--- .../collection1/solrconfig-single-core.xml | 3 + 5 files changed, 13 insertions(+), 155 deletions(-) delete mode 100644 solr/modules/saved-search/src/java/org/apache/lucene/monitor/CandidateMatcher.java 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 deleted file mode 100644 index 055f1b07c87c..000000000000 --- a/solr/modules/saved-search/src/java/org/apache/lucene/monitor/CandidateMatcher.java +++ /dev/null @@ -1,125 +0,0 @@ -/* - * 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/solr/savedsearch/SavedSearchDataValues.java b/solr/modules/saved-search/src/java/org/apache/solr/savedsearch/SavedSearchDataValues.java index e53e37ce3519..186a094e7de7 100644 --- 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 @@ -75,7 +75,7 @@ public String getMq() throws IOException { if (mqIt != null && mqIt.advanceExact(currentDoc)) { return mqIt.lookupOrd(mqIt.ordValue()).utf8ToString(); } - return reader.document(currentDoc).get(MONITOR_QUERY); + return reader.storedFields().document(currentDoc).get(MONITOR_QUERY); } public long getVersion() throws IOException { 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 index a47ecf8b0aa5..3d5cd32cd0cc 100644 --- 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 @@ -373,16 +373,17 @@ public boolean regenerateItem( var reader = searcher.getIndexReader(); int batchSize = Math.min(MAX_BATCH_SIZE, cache.getInitialSize()); boolean isDone = false; - int countBasedBatches = cache.getInitialSize() / batchSize - 1; - long targetInitialRam = ((DefaultSavedSearchCache) newCache).initialRamMB * 1024L * 1024L; + int countBasedBatches = cache.getInitialSize() / batchSize; + long targetInitialRam = cache.initialRamMB * 1024L * 1024L; long estimatedWeight = 0; SolrCore core = searcher.getCore(); SavedSearchDecoder decoder = new SavedSearchDecoder(core); long maxEncounteredVersion = cache.versionHighWaterMark; for (LeafReaderContext ctx : reader.leaves()) { + var leafSearcher = new IndexSearcher(ctx.reader()); var topDocs = - new IndexSearcher(ctx.reader()) - .search(versionRangeQuery(cache.versionHighWaterMark), batchSize, VERSION_SORT) + leafSearcher.search( + versionRangeQuery(cache.versionHighWaterMark), batchSize, VERSION_SORT) .scoreDocs; Arrays.sort(topDocs, (a, b) -> Long.compare(b.doc, a.doc)); long maxLeafVersion = -1; @@ -401,8 +402,7 @@ public boolean regenerateItem( } } topDocs = - new IndexSearcher(ctx.reader()) - .search(versionRangeQuery(maxLeafVersion + 1), batchSize, VERSION_SORT) + leafSearcher.search(versionRangeQuery(maxLeafVersion + 1), batchSize, VERSION_SORT) .scoreDocs; Arrays.sort(topDocs, (a, b) -> Long.compare(b.doc, a.doc)); if (targetInitialRam > 0L) { 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 index 9c2aaa355429..6356269d087e 100644 --- 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 @@ -22,7 +22,6 @@ import java.io.IOException; import java.util.Collection; import org.apache.lucene.index.LeafReaderContext; -import org.apache.lucene.search.BulkScorer; import org.apache.lucene.search.ConstantScoreQuery; import org.apache.lucene.search.DocIdSetIterator; import org.apache.lucene.search.Explanation; @@ -106,15 +105,6 @@ public Explanation explain(LeafReaderContext context, int doc) throws IOExceptio 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; @@ -125,22 +115,18 @@ 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); + Scorer scorer = presearchWeight.scorer(context); if (scorer == null) { return null; } + Scorer wrappedScorer = new ReverseSearchScorer(scorer, reverseSearchContext, context); return new ScorerSupplier() { @Override public Scorer get(long leadCost) { - return scorer; + return wrappedScorer; } @Override @@ -171,7 +157,6 @@ static class ReverseSearchScorer extends Scorer { ReverseSearchContext reverseSearchContext, LeafReaderContext leafReaderContext) throws IOException { - super(presearchScorer.getWeight()); this.presearchScorer = presearchScorer; this.savedSearchCache = reverseSearchContext.queryCache; this.queryDecoder = reverseSearchContext.queryDecoder; @@ -202,11 +187,6 @@ 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); 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 index fe692d246cad..5fc8f356f56b 100644 --- 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 @@ -30,6 +30,9 @@ ${solr.lock.type:native} + + 16 + From cfa34268dcec446da22fac1b818e07004c226d37 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Mon, 8 Sep 2025 14:39:03 -0400 Subject: [PATCH 82/85] update lucene-monitor license --- solr/licenses/lucene-monitor-10.2.1.jar.sha1 | 1 + solr/licenses/lucene-monitor-9.11.1.jar.sha1 | 1 - 2 files changed, 1 insertion(+), 1 deletion(-) create mode 100644 solr/licenses/lucene-monitor-10.2.1.jar.sha1 delete mode 100644 solr/licenses/lucene-monitor-9.11.1.jar.sha1 diff --git a/solr/licenses/lucene-monitor-10.2.1.jar.sha1 b/solr/licenses/lucene-monitor-10.2.1.jar.sha1 new file mode 100644 index 000000000000..6a3002ba6340 --- /dev/null +++ b/solr/licenses/lucene-monitor-10.2.1.jar.sha1 @@ -0,0 +1 @@ +28f441a84d0b5e2ae11e1585e03144ccd7ad1f0c diff --git a/solr/licenses/lucene-monitor-9.11.1.jar.sha1 b/solr/licenses/lucene-monitor-9.11.1.jar.sha1 deleted file mode 100644 index 5904d0eb15b9..000000000000 --- a/solr/licenses/lucene-monitor-9.11.1.jar.sha1 +++ /dev/null @@ -1 +0,0 @@ -fa731be343ec79d940c7abd0dd8ff1de9bf9c7f1 From 35b2a4075dbc19805befee07753f662f19219be8 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Tue, 9 Sep 2025 11:46:46 -0400 Subject: [PATCH 83/85] remove referential equality --- .../org/apache/solr/savedsearch/search/ReverseSearchQuery.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) 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 index 6356269d087e..292fddb3d069 100644 --- 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 @@ -21,6 +21,7 @@ import java.io.IOException; import java.util.Collection; +import java.util.Objects; import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.search.ConstantScoreQuery; import org.apache.lucene.search.DocIdSetIterator; @@ -62,7 +63,7 @@ public boolean equals(Object o) { @Override public Query rewrite(IndexSearcher indexSearcher) throws IOException { Query rewritten = presearchQuery.rewrite(indexSearcher); - if (rewritten != presearchQuery) { + if (!Objects.equals(rewritten, presearchQuery)) { return new ReverseSearchQuery(reverseSearchContext, presearchQuery.rewrite(indexSearcher)); } return super.rewrite(indexSearcher); From c6e207ec3de29f9a2e2a919cb94b899bcde7a2c7 Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Tue, 9 Sep 2025 19:22:32 -0400 Subject: [PATCH 84/85] keep track of max version per segment --- .../cache/DefaultSavedSearchCache.java | 31 ++++++++++--------- 1 file changed, 16 insertions(+), 15 deletions(-) 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 index 3d5cd32cd0cc..d049fc4dee5f 100644 --- 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 @@ -32,6 +32,9 @@ import java.util.concurrent.atomic.AtomicReference; import java.util.function.BiPredicate; import org.apache.lucene.document.LongPoint; +import org.apache.lucene.index.IndexReader; +import org.apache.lucene.index.IndexReader.CacheKey; +import org.apache.lucene.index.LeafReader; import org.apache.lucene.index.LeafReaderContext; import org.apache.lucene.monitor.Visitors.QueryTermFilterVisitor; import org.apache.lucene.search.IndexSearcher; @@ -62,8 +65,6 @@ public class DefaultSavedSearchCache extends SolrCacheBase SavedSearchCache, RemovalListener { - private static final long START_HIGH_WATER_MARK = -1; - private final AtomicReference currentStats = new AtomicReference<>(CurrentStats.init()); @@ -79,7 +80,8 @@ public class DefaultSavedSearchCache extends SolrCacheBase private long docVisits; // only needs to be an approximation - private long versionHighWaterMark = START_HIGH_WATER_MARK; + private Cache maxVersionMap = + Caffeine.newBuilder().weakKeys().build(); private int initialSize; private int maxSize; private int maxRamMB; @@ -199,7 +201,7 @@ public void warm(SolrIndexSearcher searcher, SolrCache boolean regenerateItem( int batchSize = Math.min(MAX_BATCH_SIZE, cache.getInitialSize()); boolean isDone = false; int countBasedBatches = cache.getInitialSize() / batchSize; - long targetInitialRam = cache.initialRamMB * 1024L * 1024L; + long targetInitialRam = ((DefaultSavedSearchCache) newCache).initialRamMB * 1024L * 1024L; long estimatedWeight = 0; SolrCore core = searcher.getCore(); SavedSearchDecoder decoder = new SavedSearchDecoder(core); - long maxEncounteredVersion = cache.versionHighWaterMark; for (LeafReaderContext ctx : reader.leaves()) { - var leafSearcher = new IndexSearcher(ctx.reader()); + LeafReader leafReader = ctx.reader(); + CacheKey cacheKey = leafReader.getCoreCacheHelper().getKey(); + long maxLeafVersion = cache.maxVersionMap.get(cacheKey, __ -> -1L); var topDocs = - leafSearcher.search( - versionRangeQuery(cache.versionHighWaterMark), batchSize, VERSION_SORT) + new IndexSearcher(leafReader) + .search(versionRangeQuery(maxLeafVersion), batchSize, VERSION_SORT) .scoreDocs; Arrays.sort(topDocs, (a, b) -> Long.compare(b.doc, a.doc)); - long maxLeafVersion = -1; while (topDocs.length > 0 && !isDone) { SavedSearchDataValues dataValues = new SavedSearchDataValues(ctx, core.getLatestSchema().getUniqueKeyField().getName()); @@ -396,13 +397,13 @@ public boolean regenerateItem( estimatedWeight += RamUsageEstimator.sizeOf(cacheEntry.entry.getMatchQuery()); estimatedWeight += RamUsageEstimator.sizeOf(cacheEntry.entry.getId()); long version = dataValues.getVersion(); - maxEncounteredVersion = Math.max(maxEncounteredVersion, version); maxLeafVersion = Math.max(maxLeafVersion, version); cache.docVisits++; } } topDocs = - leafSearcher.search(versionRangeQuery(maxLeafVersion + 1), batchSize, VERSION_SORT) + new IndexSearcher(leafReader) + .search(versionRangeQuery(maxLeafVersion + 1), batchSize, VERSION_SORT) .scoreDocs; Arrays.sort(topDocs, (a, b) -> Long.compare(b.doc, a.doc)); if (targetInitialRam > 0L) { @@ -411,8 +412,8 @@ public boolean regenerateItem( isDone = --countBasedBatches <= 0; } } + cache.maxVersionMap.put(cacheKey, maxLeafVersion); } - cache.versionHighWaterMark = Math.max(cache.versionHighWaterMark, maxEncounteredVersion); return false; } From 58caac915b321b758c10c16596349116801c787c Mon Sep 17 00:00:00 2001 From: Luke Kot-Zaniewski Date: Tue, 9 Sep 2025 19:23:38 -0400 Subject: [PATCH 85/85] don't reject unsupported fields because it breaks tlog replay --- .../SavedSearchUpdateProcessorFactory.java | 12 --------- .../SingleCoreSavedSearchTest.java | 27 ------------------- 2 files changed, 39 deletions(-) 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 index 0103e2049316..29757a34965d 100644 --- 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 @@ -124,18 +124,6 @@ public void processAdd(AddUpdateCommand cmd) throws IOException { + 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) 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 index 7ba45ed3df76..968ac60260d9 100644 --- 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 @@ -94,33 +94,6 @@ public void missingQueryFieldTest() { 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", - SavedSearchDataValues.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(