From f6c5af9c96adef93588f1a66943706eab1d558ff Mon Sep 17 00:00:00 2001 From: Christos Malliaridis Date: Wed, 13 Nov 2024 14:40:25 +0100 Subject: [PATCH 01/33] Update com.google.errorprone:* to 2.31.0 (#2862) * Update com.google.errorprone:* to 2.31.0 * Remove impossible null comparison * Suppress wanted method references * Fix ClassCanBeStatic warnings * Remove null checks for primitive data types --- gradle/validation/error-prone.gradle | 23 ++++++++++++++++++- .../solr/pkg/PackageListeningClassLoader.java | 3 +++ .../ClassificationUpdateProcessorFactory.java | 3 +-- .../handler/admin/IndexSizeEstimatorTest.java | 2 -- .../handler/admin/api/ReloadCoreAPITest.java | 1 - .../handler/admin/api/UnloadCoreAPITest.java | 1 - .../error_prone_annotations-2.28.0.jar.sha1 | 1 - .../error_prone_annotations-2.31.0.jar.sha1 | 1 + .../org/apache/solr/ltr/feature/Feature.java | 6 ++--- .../ltr/feature/OriginalScoreFeature.java | 2 +- .../apache/solr/ltr/feature/SolrFeature.java | 2 +- .../solr/common/cloud/SolrZkClient.java | 3 +++ .../solrj/request/TestUpdateRequestCodec.java | 3 +++ .../org/apache/solr/cloud/ZkTestServer.java | 2 +- versions.lock | 2 +- versions.props | 2 +- 16 files changed, 41 insertions(+), 16 deletions(-) delete mode 100644 solr/licenses/error_prone_annotations-2.28.0.jar.sha1 create mode 100644 solr/licenses/error_prone_annotations-2.31.0.jar.sha1 diff --git a/gradle/validation/error-prone.gradle b/gradle/validation/error-prone.gradle index 00e14ed0eab..647ebdeb4fb 100644 --- a/gradle/validation/error-prone.gradle +++ b/gradle/validation/error-prone.gradle @@ -179,6 +179,7 @@ allprojects { prj -> '-Xep:MathRoundIntLong:ERROR', // '-Xep:MislabeledAndroidString:OFF', // we don't use android '-Xep:MisplacedScopeAnnotations:ERROR', + // '-Xep:MissingRuntimeRetention:ERROR', // todo check if useful or comment why not // '-Xep:MissingSuperCall:OFF', // we don't use this annotation // '-Xep:MissingTestCall:OFF', // we don't use this annotation '-Xep:MisusedDayOfYear:ERROR', @@ -218,12 +219,15 @@ allprojects { prj -> '-Xep:RandomCast:ERROR', '-Xep:RandomModInteger:ERROR', // '-Xep:RectIntersectReturnValueIgnored:OFF', // we don't use android + // '-Xep:RedundantSetterCall:ERROR', // todo check if useful or comment why not // '-Xep:RequiredModifiers:OFF', // we don't use this annotation // '-Xep:RestrictedApiChecker:OFF', // we don't use this annotation // '-Xep:ReturnValueIgnored:OFF', // todo there are problems that should be fixed + // '-Xep:SelfAssertion:ERROR', // todo check if useful or comment why not '-Xep:SelfAssignment:ERROR', '-Xep:SelfComparison:ERROR', '-Xep:SelfEquals:ERROR', + // '-Xep:SetUnrecognized:ERROR', // todo check if useful or comment why not // '-Xep:ShouldHaveEvenArgs:OFF', // we don't use truth '-Xep:SizeGreaterThanOrEqualsZero:ERROR', '-Xep:StreamToString:ERROR', @@ -236,7 +240,6 @@ allprojects { prj -> // '-Xep:ThrowIfUncheckedKnownChecked:OFF', // we don't use this annotation '-Xep:ThrowNull:ERROR', '-Xep:TreeToString:ERROR', - // '-Xep:TruthSelfEquals:OFF', // we don't use truth '-Xep:TryFailThrowable:ERROR', '-Xep:TypeParameterQualifier:ERROR', '-Xep:UnicodeDirectionalityCharacters:ERROR', @@ -265,6 +268,7 @@ allprojects { prj -> '-Xep:AssertionFailureIgnored:WARN', '-Xep:AssistedInjectAndInjectOnSameConstructor:WARN', '-Xep:AttemptedNegativeZero:WARN', + // '-Xep:AutoValueBoxedValues:WARN', // todo check if useful or comment why not // '-Xep:AutoValueFinalMethods:OFF', // we don't use autovalue // '-Xep:AutoValueImmutableFields:OFF', // we don't use autovalue // '-Xep:AutoValueSubclassLeaked:OFF', // we don't use autovalue @@ -285,6 +289,7 @@ allprojects { prj -> '-Xep:ChainedAssertionLosesContext:WARN', '-Xep:CharacterGetNumericValue:WARN', '-Xep:ClassCanBeStatic:WARN', + // '-Xep:ClassInitializationDeadlock:WARN', // todo check if useful or comment why not '-Xep:ClassNewInstance:WARN', // '-Xep:CloseableProvides:OFF', // we don't use this annotation '-Xep:ClosingStandardOutputStreams:WARN', @@ -296,6 +301,8 @@ allprojects { prj -> '-Xep:DateChecker:WARN', '-Xep:DateFormatConstant:WARN', // '-Xep:DefaultCharset:OFF', // we have forbiddenapis for that + //'-Xep:DeeplyNested:WARN', // todo check if useful or comment why not + //'-Xep:DefaultLocale:WARN', // todo check if useful or comment why not '-Xep:DefaultPackage:WARN', '-Xep:DeprecatedVariable:WARN', '-Xep:DirectInvocationOnMock:WARN', @@ -309,6 +316,7 @@ allprojects { prj -> '-Xep:EmptyBlockTag:WARN', // '-Xep:EmptyCatch:OFF', // todo check if useful or comment why not - might be handled by ECJ? // '-Xep:EmptySetMultibindingContributions:OFF', // we don't use this annotation + // '-Xep:EnumOrdinal:WARN', // todo check if useful or comment why not '-Xep:EqualsGetClass:WARN', '-Xep:EqualsIncompatibleType:WARN', '-Xep:EqualsUnsafeCast:WARN', @@ -330,6 +338,7 @@ allprojects { prj -> // '-Xep:FragmentNotInstantiable:OFF', // we don't use android // '-Xep:FutureReturnValueIgnored:OFF', // todo there are problems that should be fixed '-Xep:GetClassOnEnum:WARN', + // '-Xep:GuiceNestedCombine:WARN', // todo check if useful or comment why not '-Xep:HidingField:WARN', '-Xep:ICCProfileGetInstance:WARN', '-Xep:IdentityHashMapUsage:WARN', @@ -383,6 +392,7 @@ allprojects { prj -> '-Xep:JodaPlusMinusLong:WARN', '-Xep:JodaTimeConverterManager:WARN', '-Xep:JodaWithDurationAddedLong:WARN', + // '-Xep:JUnitIncompatibleType:WARN', // todo check if useful or comment why not // '-Xep:LabelledBreakTarget:OFF', // stylistic '-Xep:LiteEnumValueOf:WARN', '-Xep:LiteProtoToString:WARN', @@ -403,10 +413,12 @@ allprojects { prj -> // '-Xep:MissingSummary:OFF', // style preference that we don't want to enforce // '-Xep:MixedMutabilityReturnType:OFF', // todo check if useful or comment why not '-Xep:MockNotUsedInProduction:WARN', + // '-Xep:MockitoDoSetup:WARN', // todo check if useful or comment why not '-Xep:ModifiedButNotUsed:WARN', '-Xep:ModifyCollectionInEnhancedForLoop:WARN', '-Xep:ModifySourceCollectionInStream:WARN', '-Xep:MultimapKeys:WARN', + // '-Xep:MultipleNullnessAnnotations:WARN', // todo check if useful or comment why not '-Xep:MultipleParallelOrSequentialCalls:WARN', '-Xep:MultipleUnaryOperatorsInMethodCall:WARN', // '-Xep:MutableGuiceModule:OFF', // we don't use guice @@ -428,7 +440,9 @@ allprojects { prj -> '-Xep:NullableOptional:WARN', // '-Xep:NullablePrimitive:OFF', // we don't use this annotation // '-Xep:NullablePrimitiveArray:OFF', // we don't use this annotation + // '-Xep:NullableTypeParameter:WARN', // todo check if useful or comment why not // '-Xep:NullableVoid:OFF', // we don't use this annotation + // '-Xep:NullableWildcard:WARN', // todo check if useful or comment why not '-Xep:ObjectEqualsForPrimitives:WARN', // '-Xep:ObjectToString:OFF', // todo check if useful or comment why not '-Xep:ObjectsHashCodePrimitive:WARN', @@ -442,6 +456,7 @@ allprojects { prj -> '-Xep:Overrides:WARN', // '-Xep:OverridesGuiceInjectableMethod:OFF', // we don't use guice '-Xep:ParameterName:WARN', + // '-Xep:PatternMatchingInstanceof:WARN', // todo check if useful or comment why not '-Xep:PreconditionsCheckNotNullRepeated:WARN', '-Xep:PrimitiveAtomicReference:WARN', '-Xep:ProtectedMembersInFinalClass:WARN', @@ -459,6 +474,7 @@ allprojects { prj -> // '-Xep:SameNameButDifferent:OFF', // todo check if useful or comment why not '-Xep:SelfAlwaysReturnsThis:WARN', // '-Xep:ShortCircuitBoolean:OFF', // todo check if useful or comment why not + // '-Xep:StatementSwitchToExpressionSwitch:WARN', // todo check if useful or comment why not // '-Xep:StaticAssignmentInConstructor:OFF', // we assign SolrTestCaseJ4.configString in many tests, difficult to untangle '-Xep:StaticAssignmentOfThrowable:WARN', // '-Xep:StaticGuardedByInstance:OFF', // todo check if useful or comment why not @@ -469,9 +485,12 @@ allprojects { prj -> '-Xep:StringCharset:WARN', '-Xep:StringFormatWithLiteral:WARN', // '-Xep:StringSplitter:OFF', // todo check if useful or comment why not - might be able to use forbidden-apis for this? + // '-Xep:SunApi:WARN', // todo check if useful or comment why not + // '-Xep:SuperCallToObjectMethod:WARN', // todo check if useful or comment why not '-Xep:SuperEqualsIsObjectEquals:WARN', // '-Xep:SwigMemoryLeak:OFF', // we don't use swig // '-Xep:SynchronizeOnNonFinalField:OFF', // todo check if useful or comment why not + // '-Xep:SystemConsoleNull:WARN', // todo check if useful or comment why not // '-Xep:ThreadJoinLoop:OFF', // todo check if useful or comment why not // '-Xep:ThreadLocalUsage:OFF', // todo check if useful or comment why not // '-Xep:ThreadPriorityCheck:OFF', // todo check if useful or comment why not @@ -493,6 +512,7 @@ allprojects { prj -> // '-Xep:UnicodeEscape:OFF', // can't enable since Lucene/Solr tests use unicode a bunch // '-Xep:UnnecessaryAssignment:OFF', // we don't use these annotations '-Xep:UnnecessaryAsync:WARN', + // '-Xep:UnnecessaryBreakInSwitch:WARN', // todo check if useful or comment why not '-Xep:UnnecessaryLambda:WARN', '-Xep:UnnecessaryLongToIntConversion:WARN', '-Xep:UnnecessaryMethodInvocationMatcher:WARN', @@ -513,6 +533,7 @@ allprojects { prj -> // '-Xep:UseBinds:OFF', // we don't use this annotation // '-Xep:UseCorrectAssertInTests:OFF', // we inherit from LuceneTestCase which extends Assert '-Xep:VariableNameSameAsType:WARN', + // '-Xep:VoidUsed:WARN', // todo check if useful or comment why not // '-Xep:WaitNotInLoop:OFF', // todo check if useful or comment why not // '-Xep:WakelockReleasedDangerously:OFF', // we don't use android // '-Xep:WithSignatureDiscouraged:OFF', // we aren't using this error-prone internal api diff --git a/solr/core/src/java/org/apache/solr/pkg/PackageListeningClassLoader.java b/solr/core/src/java/org/apache/solr/pkg/PackageListeningClassLoader.java index 65d46edd5ad..272de544b6e 100644 --- a/solr/core/src/java/org/apache/solr/pkg/PackageListeningClassLoader.java +++ b/solr/core/src/java/org/apache/solr/pkg/PackageListeningClassLoader.java @@ -105,6 +105,9 @@ public SolrPackageLoader.SolrPackage.Version findPackageVersion( return theVersion; } + // Allow method reference to return a reference to a functional interface (Mapwriter), + // rather than a reference to a PgkVersion object + @SuppressWarnings("UnnecessaryMethodReference") @Override public MapWriter getPackageVersion(PluginInfo.ClassName cName) { if (cName.pkg == null) return null; diff --git a/solr/core/src/java/org/apache/solr/update/processor/ClassificationUpdateProcessorFactory.java b/solr/core/src/java/org/apache/solr/update/processor/ClassificationUpdateProcessorFactory.java index 1d0e57bc3e9..7f599682eaf 100644 --- a/solr/core/src/java/org/apache/solr/update/processor/ClassificationUpdateProcessorFactory.java +++ b/solr/core/src/java/org/apache/solr/update/processor/ClassificationUpdateProcessorFactory.java @@ -92,8 +92,7 @@ public void init(final NamedList args) { String algorithmString = params.get(ALGORITHM_PARAM); Algorithm classificationAlgorithm; try { - if (algorithmString == null - || Algorithm.valueOf(algorithmString.toUpperCase(Locale.ROOT)) == null) { + if (algorithmString == null) { classificationAlgorithm = DEFAULT_ALGORITHM; } else { classificationAlgorithm = Algorithm.valueOf(algorithmString.toUpperCase(Locale.ROOT)); diff --git a/solr/core/src/test/org/apache/solr/handler/admin/IndexSizeEstimatorTest.java b/solr/core/src/test/org/apache/solr/handler/admin/IndexSizeEstimatorTest.java index e175497aa36..5523ad23c15 100644 --- a/solr/core/src/test/org/apache/solr/handler/admin/IndexSizeEstimatorTest.java +++ b/solr/core/src/test/org/apache/solr/handler/admin/IndexSizeEstimatorTest.java @@ -227,8 +227,6 @@ public void testIntegration() throws Exception { (k, v) -> { double size = fromHumanReadableUnits((String) v); double sampledSize = fromHumanReadableUnits((String) sampledFieldsBySize.get(k)); - assertNotNull( - "sampled size missing for field " + k + " in " + sampledFieldsBySize, sampledSize); double delta = size * 0.5; assertEquals("sampled size of " + k + " is wildly off", size, sampledSize, delta); }); diff --git a/solr/core/src/test/org/apache/solr/handler/admin/api/ReloadCoreAPITest.java b/solr/core/src/test/org/apache/solr/handler/admin/api/ReloadCoreAPITest.java index 304717a167a..fc73c6781f9 100644 --- a/solr/core/src/test/org/apache/solr/handler/admin/api/ReloadCoreAPITest.java +++ b/solr/core/src/test/org/apache/solr/handler/admin/api/ReloadCoreAPITest.java @@ -57,7 +57,6 @@ public void setUp() throws Exception { public void testValidReloadCoreAPIResponse() throws Exception { SolrJerseyResponse response = reloadCoreAPI.reloadCore(coreName, new ReloadCoreRequestBody()); assertEquals(0, response.responseHeader.status); - assertNotNull(response.responseHeader.qTime); } @Test diff --git a/solr/core/src/test/org/apache/solr/handler/admin/api/UnloadCoreAPITest.java b/solr/core/src/test/org/apache/solr/handler/admin/api/UnloadCoreAPITest.java index d2dcc732b2c..c823f33dea1 100644 --- a/solr/core/src/test/org/apache/solr/handler/admin/api/UnloadCoreAPITest.java +++ b/solr/core/src/test/org/apache/solr/handler/admin/api/UnloadCoreAPITest.java @@ -56,7 +56,6 @@ public void setUp() throws Exception { public void testValidUnloadCoreAPIResponse() throws Exception { SolrJerseyResponse response = unloadCoreAPI.unloadCore(coreName, getUnloadCoreRequestBodyObj()); assertEquals(0, response.responseHeader.status); - assertNotNull(response.responseHeader.qTime); } @Test diff --git a/solr/licenses/error_prone_annotations-2.28.0.jar.sha1 b/solr/licenses/error_prone_annotations-2.28.0.jar.sha1 deleted file mode 100644 index 4839239eabf..00000000000 --- a/solr/licenses/error_prone_annotations-2.28.0.jar.sha1 +++ /dev/null @@ -1 +0,0 @@ -59fc00087ce372de42e394d2c789295dff2d19f0 diff --git a/solr/licenses/error_prone_annotations-2.31.0.jar.sha1 b/solr/licenses/error_prone_annotations-2.31.0.jar.sha1 new file mode 100644 index 00000000000..1fa88710c6d --- /dev/null +++ b/solr/licenses/error_prone_annotations-2.31.0.jar.sha1 @@ -0,0 +1 @@ +c3ba307b915d6d506e98ffbb49e6d2d12edad65b diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/Feature.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/Feature.java index f07f624f3f1..f3fe61c3fb5 100644 --- a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/Feature.java +++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/Feature.java @@ -302,7 +302,7 @@ public String toString() { } /** A 'recipe' for computing a feature */ - public abstract class FeatureScorer extends Scorer { + public abstract static class FeatureScorer extends Scorer { protected final String name; private DocInfo docInfo; @@ -342,7 +342,7 @@ public DocIdSetIterator iterator() { * A FeatureScorer that contains a Scorer, which it delegates to where * appropriate. */ - public abstract class FilterFeatureScorer extends FeatureScorer { + public abstract static class FilterFeatureScorer extends FeatureScorer { protected final Scorer in; @@ -380,7 +380,7 @@ public float getMaxScore(int upTo) throws IOException { * Default FeatureScorer class that returns the score passed in. Can be used as a simple * ValueFeature, or to return a default scorer in case an underlying feature's scorer is null. */ - public class ValueFeatureScorer extends FeatureScorer { + public static class ValueFeatureScorer extends FeatureScorer { float constScore; public ValueFeatureScorer(FeatureWeight weight, float constScore, DocIdSetIterator itr) { diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/OriginalScoreFeature.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/OriginalScoreFeature.java index a74e930641b..e2b4e8d93ad 100644 --- a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/OriginalScoreFeature.java +++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/OriginalScoreFeature.java @@ -91,7 +91,7 @@ public FeatureScorer scorer(LeafReaderContext context) throws IOException { return new OriginalScoreScorer(this, originalScorer); } - public class OriginalScoreScorer extends FilterFeatureScorer { + public static class OriginalScoreScorer extends FilterFeatureScorer { public OriginalScoreScorer(FeatureWeight weight, Scorer originalScorer) { super(weight, originalScorer); diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/SolrFeature.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/SolrFeature.java index 2162dfd3ecb..5c696b6f96f 100644 --- a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/SolrFeature.java +++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/SolrFeature.java @@ -234,7 +234,7 @@ public FeatureScorer scorer(LeafReaderContext context) throws IOException { } /** Scorer for a SolrFeature */ - public class SolrFeatureScorer extends FilterFeatureScorer { + public static class SolrFeatureScorer extends FilterFeatureScorer { public SolrFeatureScorer(FeatureWeight weight, Scorer solrScorer) { super(weight, solrScorer); diff --git a/solr/solrj-zookeeper/src/java/org/apache/solr/common/cloud/SolrZkClient.java b/solr/solrj-zookeeper/src/java/org/apache/solr/common/cloud/SolrZkClient.java index d8abea5529d..9c1fe5778c3 100644 --- a/solr/solrj-zookeeper/src/java/org/apache/solr/common/cloud/SolrZkClient.java +++ b/solr/solrj-zookeeper/src/java/org/apache/solr/common/cloud/SolrZkClient.java @@ -89,6 +89,9 @@ public class SolrZkClient implements Closeable { private Compressor compressor; private int minStateByteLenForCompression; + // Allow method reference to return a reference to a functional interface (Mapwriter), + // rather than a reference to a ZkMetrics object + @SuppressWarnings("UnnecessaryMethodReference") public MapWriter getMetrics() { return metrics::writeMap; } diff --git a/solr/solrj/src/test/org/apache/solr/client/solrj/request/TestUpdateRequestCodec.java b/solr/solrj/src/test/org/apache/solr/client/solrj/request/TestUpdateRequestCodec.java index e8c72a52b44..ef24375ca16 100644 --- a/solr/solrj/src/test/org/apache/solr/client/solrj/request/TestUpdateRequestCodec.java +++ b/solr/solrj/src/test/org/apache/solr/client/solrj/request/TestUpdateRequestCodec.java @@ -110,6 +110,9 @@ public void simple() throws IOException { assertEquals("b", updateUnmarshalled.getParams().get("a")); } + // Allow method reference to return a reference to a functional interface (Iterable), + // rather than a reference to a List object + @SuppressWarnings("UnnecessaryMethodReference") @Test public void testIterable() throws IOException { final List values = new ArrayList<>(); diff --git a/solr/test-framework/src/java/org/apache/solr/cloud/ZkTestServer.java b/solr/test-framework/src/java/org/apache/solr/cloud/ZkTestServer.java index 8bd7396c7a7..2041760c0d4 100644 --- a/solr/test-framework/src/java/org/apache/solr/cloud/ZkTestServer.java +++ b/solr/test-framework/src/java/org/apache/solr/cloud/ZkTestServer.java @@ -266,7 +266,7 @@ private void updateForFire(WatchedEvent event) { } } - private class TestZKDatabase extends ZKDatabase { + private static class TestZKDatabase extends ZKDatabase { private final WatchLimiter limiter; diff --git a/versions.lock b/versions.lock index 04ea37b692a..17ce70225e3 100644 --- a/versions.lock +++ b/versions.lock @@ -46,7 +46,7 @@ com.google.cloud:google-cloud-core-grpc:2.40.0 (1 constraints: 1a1001a6) com.google.cloud:google-cloud-core-http:2.40.0 (1 constraints: 1a1001a6) com.google.cloud:google-cloud-storage:2.40.1 (2 constraints: cf1cc626) com.google.code.gson:gson:2.11.0 (6 constraints: 0c550bc0) -com.google.errorprone:error_prone_annotations:2.28.0 (15 constraints: a5c51259) +com.google.errorprone:error_prone_annotations:2.31.0 (15 constraints: a5c51259) com.google.guava:failureaccess:1.0.2 (2 constraints: fb19bf37) com.google.guava:guava:33.1.0-jre (27 constraints: 698fe64d) com.google.guava:listenablefuture:9999.0-empty-to-avoid-conflict-with-guava (2 constraints: 4b35b0a0) diff --git a/versions.props b/versions.props index 286700c1d75..946b3d97e6d 100644 --- a/versions.props +++ b/versions.props @@ -10,7 +10,7 @@ com.github.ben-manes.caffeine:caffeine=3.1.8 com.github.spotbugs:*=4.8.6 com.github.stephenc.jcip:jcip-annotations=1.0-1 com.google.cloud:google-cloud-bom=0.224.0 -com.google.errorprone:*=2.23.0 +com.google.errorprone:*=2.31.0 com.google.guava:guava=32.1.3-jre com.google.re2j:re2j=1.7 com.j256.simplemagic:simplemagic=1.17 From 4b9e539257512801cf740d9bc142a95a99576103 Mon Sep 17 00:00:00 2001 From: Eric Pugh Date: Wed, 13 Nov 2024 15:32:46 -0500 Subject: [PATCH 02/33] SOLR-14673: Add bin/solr stream CLI (#2479) * Allows you to run a streaming expression on the Solr server, using the /stream end point. * Allows you to run a streaming expression locally, by specifying --execution=local. --- solr/CHANGES.txt | 2 + solr/bin/solr.cmd | 4 +- .../src/java/org/apache/solr/cli/SolrCLI.java | 4 +- .../java/org/apache/solr/cli/StreamTool.java | 531 ++++++++++++++++++ .../org/apache/solr/handler/CatStream.java | 5 +- .../org/apache/solr/cli/StreamToolTest.java | 366 ++++++++++++ solr/packaging/test/test_stream.bats | 86 +++ .../query-guide/pages/stream-tool.adoc | 176 ++++++ .../pages/streaming-expressions.adoc | 4 + .../modules/query-guide/querying-nav.adoc | 1 + .../solr/client/solrj/io/SolrClientCache.java | 29 +- .../client/solrj/io/stream/LetStream.java | 5 + 12 files changed, 1197 insertions(+), 16 deletions(-) create mode 100644 solr/core/src/java/org/apache/solr/cli/StreamTool.java create mode 100644 solr/core/src/test/org/apache/solr/cli/StreamToolTest.java create mode 100644 solr/packaging/test/test_stream.bats create mode 100644 solr/solr-ref-guide/modules/query-guide/pages/stream-tool.adoc diff --git a/solr/CHANGES.txt b/solr/CHANGES.txt index 874adfcc4d7..93e737a543d 100644 --- a/solr/CHANGES.txt +++ b/solr/CHANGES.txt @@ -12,6 +12,8 @@ New Features * SOLR-17467: Solr CLI bin/solr start defaults to starting Solr in Cloud mode, use --user-managed switch for User Managed (aka Standalone) mode. (Eric Pugh) +* SOLR-14673: Solr CLI now has bin/solr stream tool that executates streaming expressions via command line, either locally or on solr cluster. (Eric Pugh) + Improvements --------------------- diff --git a/solr/bin/solr.cmd b/solr/bin/solr.cmd index 5fd6ec44aea..9f875926517 100755 --- a/solr/bin/solr.cmd +++ b/solr/bin/solr.cmd @@ -1175,9 +1175,9 @@ for %%a in (%*) do ( ) else ( set "option!option!=%%a" if "!option!" equ "-s" set "SOLR_HOME=%%a" - if "!option!" equ "--solr-home" set "SOLR_HOME=%%a" + if "!option!" equ "--solr-home" set "SOLR_HOME=%%a" if "!option!" equ "-d" set "SOLR_SERVER_DIR=%%a" - if "!option!" equ "--server-dir" set "SOLR_SERVER_DIR=%%a" + if "!option!" equ "--server-dir" set "SOLR_SERVER_DIR=%%a" if not "!option!" equ "-s" if not "!option!" equ "--solr-home" if not "!option!" equ "-d" if not "!option!" equ "--server-dir" ( set "AUTH_PARAMS=!AUTH_PARAMS! !option! %%a" ) diff --git a/solr/core/src/java/org/apache/solr/cli/SolrCLI.java b/solr/core/src/java/org/apache/solr/cli/SolrCLI.java index 00a97b4434c..4714c43c99c 100755 --- a/solr/core/src/java/org/apache/solr/cli/SolrCLI.java +++ b/solr/core/src/java/org/apache/solr/cli/SolrCLI.java @@ -246,6 +246,7 @@ private static Tool newTool(String toolType) throws Exception { else if ("post".equals(toolType)) return new PostTool(); else if ("postlogs".equals(toolType)) return new PostLogsTool(); else if ("version".equals(toolType)) return new VersionTool(); + else if ("stream".equals(toolType)) return new StreamTool(); else if ("snapshot-create".equals(toolType)) return new SnapshotCreateTool(); else if ("snapshot-delete".equals(toolType)) return new SnapshotDeleteTool(); else if ("snapshot-list".equals(toolType)) return new SnapshotListTool(); @@ -511,8 +512,7 @@ private static void printHelp() { print("Usage: solr COMMAND OPTIONS"); print(" where COMMAND is one of: start, stop, restart, status, "); print( - " healthcheck, create, delete, auth, assert, config, export, api, package, post, "); - + " healthcheck, create, delete, auth, assert, config, export, api, package, post, stream,"); print( " zk ls, zk cp, zk rm , zk mv, zk mkroot, zk upconfig, zk downconfig,"); print( diff --git a/solr/core/src/java/org/apache/solr/cli/StreamTool.java b/solr/core/src/java/org/apache/solr/cli/StreamTool.java new file mode 100644 index 00000000000..9c0392ec71b --- /dev/null +++ b/solr/core/src/java/org/apache/solr/cli/StreamTool.java @@ -0,0 +1,531 @@ +/* + * 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.cli; + +import java.io.BufferedReader; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.LineNumberReader; +import java.io.PrintStream; +import java.io.Reader; +import java.io.StringReader; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Locale; +import java.util.Set; +import org.apache.commons.cli.CommandLine; +import org.apache.commons.cli.Option; +import org.apache.commons.cli.Options; +import org.apache.solr.client.solrj.io.Lang; +import org.apache.solr.client.solrj.io.SolrClientCache; +import org.apache.solr.client.solrj.io.Tuple; +import org.apache.solr.client.solrj.io.comp.StreamComparator; +import org.apache.solr.client.solrj.io.stream.PushBackStream; +import org.apache.solr.client.solrj.io.stream.SolrStream; +import org.apache.solr.client.solrj.io.stream.StreamContext; +import org.apache.solr.client.solrj.io.stream.TupleStream; +import org.apache.solr.client.solrj.io.stream.expr.Explanation; +import org.apache.solr.client.solrj.io.stream.expr.Expressible; +import org.apache.solr.client.solrj.io.stream.expr.StreamExpression; +import org.apache.solr.client.solrj.io.stream.expr.StreamExpressionParser; +import org.apache.solr.client.solrj.io.stream.expr.StreamFactory; +import org.apache.solr.common.SolrException; +import org.apache.solr.common.params.ModifiableSolrParams; +import org.apache.solr.handler.CatStream; + +/** Supports stream command in the bin/solr script. */ +public class StreamTool extends ToolBase { + + public StreamTool() { + this(CLIO.getOutStream()); + } + + public StreamTool(PrintStream stdout) { + super(stdout); + } + + private final SolrClientCache solrClientCache = new SolrClientCache(); + + @Override + public String getName() { + return "stream"; + } + + @Override + public String getUsage() { + // Specify that the last argument is the streaming expression + return "bin/solr stream [--array-delimiter ] [-c ] [--delimiter ] [-e ] [-f\n" + + " ] [-h] [--header] [-s ] [-u ] [-v] [-z ] \n"; + } + + private static final Option EXECUTION_OPTION = + Option.builder("e") + .longOpt("execution") + .hasArg() + .argName("ENVIRONMENT") + .desc( + "Execution environment is either 'local' (i.e CLI process) or via a 'remote' Solr server. Default environment is 'remote'.") + .build(); + + private static final Option COLLECTION_OPTION = + Option.builder("c") + .longOpt("name") + .argName("NAME") + .hasArg() + .desc( + "Name of the specific collection to execute expression on if the execution is set to 'remote'. Required for 'remote' execution environment.") + .build(); + + private static final Option FIELDS_OPTION = + Option.builder("f") + .longOpt("fields") + .argName("FIELDS") + .hasArg() + .desc( + "The fields in the tuples to output. Defaults to fields in the first tuple of result set.") + .build(); + + private static final Option HEADER_OPTION = + Option.builder().longOpt("header").desc("Specify to include a header line.").build(); + + private static final Option DELIMITER_OPTION = + Option.builder() + .longOpt("delimiter") + .argName("CHARACTER") + .hasArg() + .desc("The output delimiter. Default to using three spaces.") + .build(); + private static final Option ARRAY_DELIMITER_OPTION = + Option.builder() + .longOpt("array-delimiter") + .argName("CHARACTER") + .hasArg() + .desc("The delimiter multi-valued fields. Default to using a pipe (|) delimiter.") + .build(); + + @Override + public Options getOptions() { + + return super.getOptions() + .addOption(EXECUTION_OPTION) + .addOption(COLLECTION_OPTION) + .addOption(FIELDS_OPTION) + .addOption(HEADER_OPTION) + .addOption(DELIMITER_OPTION) + .addOption(ARRAY_DELIMITER_OPTION) + .addOption(CommonCLIOptions.CREDENTIALS_OPTION) + .addOptionGroup(getConnectionOptions()); + } + + @Override + @SuppressWarnings({"rawtypes"}) + public void runImpl(CommandLine cli) throws Exception { + + String expressionArgument = cli.getArgs()[0]; + String execution = cli.getOptionValue(EXECUTION_OPTION, "remote"); + String arrayDelimiter = cli.getOptionValue(ARRAY_DELIMITER_OPTION, "|"); + String delimiter = cli.getOptionValue(DELIMITER_OPTION, " "); + boolean includeHeaders = cli.hasOption(HEADER_OPTION); + String[] outputHeaders = getOutputFields(cli); + + LineNumberReader bufferedReader = null; + String expr; + try { + Reader inputStream = + expressionArgument.toLowerCase(Locale.ROOT).endsWith(".expr") + ? new InputStreamReader( + new FileInputStream(expressionArgument), Charset.defaultCharset()) + : new StringReader(expressionArgument); + + bufferedReader = new LineNumberReader(inputStream); + expr = StreamTool.readExpression(bufferedReader, cli.getArgs()); + echoIfVerbose("Running Expression: " + expr); + } finally { + if (bufferedReader != null) { + bufferedReader.close(); + } + } + + PushBackStream pushBackStream; + if (execution.equalsIgnoreCase("local")) { + pushBackStream = doLocalMode(cli, expr); + } else { + pushBackStream = doRemoteMode(cli, expr); + } + + try { + pushBackStream.open(); + + if (outputHeaders == null) { + + Tuple tuple = pushBackStream.read(); + + if (!tuple.EOF) { + outputHeaders = getHeadersFromFirstTuple(tuple); + } + + pushBackStream.pushBack(tuple); + } + + if (includeHeaders) { + StringBuilder headersOut = new StringBuilder(); + if (outputHeaders != null) { + for (int i = 0; i < outputHeaders.length; i++) { + if (i > 0) { + headersOut.append(delimiter); + } + headersOut.append(outputHeaders[i]); + } + } + CLIO.out(headersOut.toString()); + } + + while (true) { + Tuple tuple = pushBackStream.read(); + if (tuple.EOF) { + break; + } else { + StringBuilder outLine = new StringBuilder(); + if (outputHeaders != null) { + for (int i = 0; i < outputHeaders.length; i++) { + if (i > 0) { + outLine.append(delimiter); + } + + Object o = tuple.get(outputHeaders[i]); + if (o != null) { + if (o instanceof List) { + List outfields = (List) o; + outLine.append(listToString(outfields, arrayDelimiter)); + } else { + outLine.append(o); + } + } + } + } + CLIO.out(outLine.toString()); + } + } + } finally { + + if (pushBackStream != null) { + pushBackStream.close(); + } + + solrClientCache.close(); + } + + echoIfVerbose("StreamTool -- Done."); + } + + /** + * Runs a streaming expression in the local process of the CLI. + * + *

Running locally means that parallelization support or those expressions requiring access to + * internal Solr capabilities will not function. + * + * @param cli The CLI invoking the call + * @param expr The streaming expression to be parsed and in the context of the CLI process + * @return A connection to the streaming expression that receives Tuples as they are emitted + * locally. + */ + private PushBackStream doLocalMode(CommandLine cli, String expr) throws Exception { + String zkHost = SolrCLI.getZkHost(cli); + + echoIfVerbose("Connecting to ZooKeeper at " + zkHost); + solrClientCache.getCloudSolrClient(zkHost); + solrClientCache.setBasicAuthCredentials( + cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION)); + + TupleStream stream; + PushBackStream pushBackStream; + + StreamExpression streamExpression = StreamExpressionParser.parse(expr); + StreamFactory streamFactory = new StreamFactory(); + + // stdin is ONLY available in the local mode, not in the remote mode as it + // requires access to System.in + streamFactory.withFunctionName("stdin", StandardInStream.class); + + // LocalCatStream extends CatStream and disables the Solr cluster specific + // logic about where to read data from. + streamFactory.withFunctionName("cat", LocalCatStream.class); + + streamFactory.withDefaultZkHost(zkHost); + + Lang.register(streamFactory); + + stream = StreamTool.constructStream(streamFactory, streamExpression); + + pushBackStream = new PushBackStream(stream); + + // Now we can run the stream and return the results. + StreamContext streamContext = new StreamContext(); + streamContext.setSolrClientCache(solrClientCache); + + // Output the headers + pushBackStream.setStreamContext(streamContext); + + return pushBackStream; + } + + /** + * Runs a streaming expression on a Solr collection via the /stream end point and returns the + * results to the CLI. Requires a collection to be specified to send the expression to. + * + *

Running remotely allows you to use all the standard Streaming Expression capabilities as the + * expression is running in a Solr environment. + * + * @param cli The CLI invoking the call + * @param expr The streaming expression to be parsed and run remotely + * @return A connection to the streaming expression that receives Tuples as they are emitted from + * Solr /stream. + */ + private PushBackStream doRemoteMode(CommandLine cli, String expr) throws Exception { + + String solrUrl = SolrCLI.normalizeSolrUrl(cli); + if (!cli.hasOption("name")) { + throw new IllegalStateException( + "You must provide --name COLLECTION with --worker solr parameter."); + } + String collection = cli.getOptionValue("name"); + + if (expr.toLowerCase(Locale.ROOT).contains("stdin(")) { + throw new IllegalStateException( + "The stdin() expression is only usable with --worker local set up."); + } + + final SolrStream solrStream = + new SolrStream(solrUrl + "/solr/" + collection, params("qt", "/stream", "expr", expr)); + + String credentials = cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION); + if (credentials != null) { + String username = credentials.split(":")[0]; + String password = credentials.split(":")[1]; + solrStream.setCredentials(username, password); + } + return new PushBackStream(solrStream); + } + + private static ModifiableSolrParams params(String... params) { + if (params.length % 2 != 0) throw new RuntimeException("Params length should be even"); + ModifiableSolrParams msp = new ModifiableSolrParams(); + for (int i = 0; i < params.length; i += 2) { + msp.add(params[i], params[i + 1]); + } + return msp; + } + + public static class StandardInStream extends TupleStream implements Expressible { + + private BufferedReader reader; + private InputStream inputStream = System.in; + private boolean doClose = false; + + public StandardInStream() {} + + public StandardInStream(StreamExpression expression, StreamFactory factory) + throws IOException {} + + @Override + public List children() { + return null; + } + + public void setInputStream(InputStream inputStream) { + this.inputStream = inputStream; + this.doClose = true; + } + + @Override + public void open() { + reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8)); + } + + @Override + public void close() throws IOException { + if (doClose) { + inputStream.close(); + } + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Override + public Tuple read() throws IOException { + String line = reader.readLine(); + HashMap map = new HashMap(); + Tuple tuple = new Tuple(map); + if (line != null) { + tuple.put("line", line); + tuple.put("file", "cat"); + } else { + tuple.put("EOF", "true"); + } + return tuple; + } + + @Override + public void setStreamContext(StreamContext context) {} + + @Override + public StreamExpression toExpression(StreamFactory factory) { + return null; + } + + @Override + public Explanation toExplanation(StreamFactory factory) { + return null; + } + + @Override + public StreamComparator getStreamSort() { + return null; + } + } + + static String[] getOutputFields(CommandLine cli) { + if (cli.hasOption(FIELDS_OPTION)) { + + String fl = cli.getOptionValue(FIELDS_OPTION); + String[] flArray = fl.split(","); + String[] outputHeaders = new String[flArray.length]; + + for (int i = 0; i < outputHeaders.length; i++) { + outputHeaders[i] = flArray[i].trim(); + } + + return outputHeaders; + + } else { + return null; + } + } + + public static class LocalCatStream extends CatStream { + + public LocalCatStream(StreamExpression expression, StreamFactory factory) throws IOException { + super(expression, factory); + } + + public LocalCatStream(String commaDelimitedFilepaths, int maxLines) { + super(commaDelimitedFilepaths, maxLines); + } + + @Override + public void setStreamContext(StreamContext context) { + // LocalCatStream has no Solr core to pull from the context + } + + @Override + protected List validateAndSetFilepathsInSandbox(String commaDelimitedFilepaths) { + final List crawlSeeds = new ArrayList<>(); + for (String crawlRootStr : commaDelimitedFilepaths.split(",")) { + Path crawlRootPath = Paths.get(crawlRootStr).normalize(); + + if (!Files.exists(crawlRootPath)) { + throw new SolrException( + SolrException.ErrorCode.BAD_REQUEST, + "file/directory to stream doesn't exist: " + crawlRootStr); + } + + crawlSeeds.add(new CrawlFile(crawlRootStr, crawlRootPath)); + } + + return crawlSeeds; + } + } + + @SuppressWarnings({"rawtypes"}) + static String[] getHeadersFromFirstTuple(Tuple tuple) { + Set fields = tuple.getFields().keySet(); + String[] outputHeaders = new String[fields.size()]; + int i = -1; + for (Object o : fields) { + outputHeaders[++i] = o.toString(); + } + Arrays.sort(outputHeaders); + return outputHeaders; + } + + @SuppressWarnings({"rawtypes"}) + static String listToString(List values, String internalDelim) { + StringBuilder buf = new StringBuilder(); + for (Object value : values) { + if (buf.length() > 0) { + buf.append(internalDelim); + } + + buf.append(value.toString()); + } + + return buf.toString(); + } + + private static TupleStream constructStream( + StreamFactory streamFactory, StreamExpression streamExpression) throws IOException { + return streamFactory.constructStream(streamExpression); + } + + static String readExpression(LineNumberReader bufferedReader, String[] args) throws IOException { + + StringBuilder exprBuff = new StringBuilder(); + + boolean comment = false; + while (true) { + String line = bufferedReader.readLine(); + if (line == null) { + break; + } + + if (line.indexOf("/*") == 0) { + comment = true; + continue; + } + + if (line.indexOf("*/") == 0) { + comment = false; + continue; + } + + if (comment || line.startsWith("#") || line.startsWith("//")) { + continue; + } + + // Substitute parameters + + if (line.length() > 0) { + for (int i = 1; i < args.length; i++) { + String arg = args[i]; + line = line.replace("$" + i, arg); + } + } + + exprBuff.append(line); + } + + return exprBuff.toString(); + } +} diff --git a/solr/core/src/java/org/apache/solr/handler/CatStream.java b/solr/core/src/java/org/apache/solr/handler/CatStream.java index 70ee2b65242..f2515f9b38b 100644 --- a/solr/core/src/java/org/apache/solr/handler/CatStream.java +++ b/solr/core/src/java/org/apache/solr/handler/CatStream.java @@ -113,7 +113,8 @@ public List children() { @Override public void open() throws IOException { - final List initialCrawlSeeds = validateAndSetFilepathsInSandbox(); + final List initialCrawlSeeds = + validateAndSetFilepathsInSandbox(this.commaDelimitedFilepaths); final List filesToCrawl = new ArrayList<>(); for (CrawlFile crawlSeed : initialCrawlSeeds) { @@ -163,7 +164,7 @@ public Explanation toExplanation(StreamFactory factory) throws IOException { .withExpression(toExpression(factory).toString()); } - private List validateAndSetFilepathsInSandbox() { + protected List validateAndSetFilepathsInSandbox(String commaDelimitedFilepaths) { final List crawlSeeds = new ArrayList<>(); for (String crawlRootStr : commaDelimitedFilepaths.split(",")) { Path crawlRootPath = chroot.resolve(crawlRootStr).normalize(); diff --git a/solr/core/src/test/org/apache/solr/cli/StreamToolTest.java b/solr/core/src/test/org/apache/solr/cli/StreamToolTest.java new file mode 100644 index 00000000000..e91ab9e2d81 --- /dev/null +++ b/solr/core/src/test/org/apache/solr/cli/StreamToolTest.java @@ -0,0 +1,366 @@ +/* + * 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.cli; + +import static org.apache.solr.cli.SolrCLI.findTool; +import static org.apache.solr.cli.SolrCLI.parseCmdLine; + +import java.io.BufferedWriter; +import java.io.ByteArrayInputStream; +import java.io.File; +import java.io.FileWriter; +import java.io.LineNumberReader; +import java.io.PrintWriter; +import java.io.StringReader; +import java.io.StringWriter; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import org.apache.commons.cli.CommandLine; +import org.apache.solr.client.solrj.SolrRequest; +import org.apache.solr.client.solrj.SolrResponse; +import org.apache.solr.client.solrj.io.Tuple; +import org.apache.solr.client.solrj.request.CollectionAdminRequest; +import org.apache.solr.cloud.SolrCloudTestCase; +import org.apache.solr.util.SecurityJson; +import org.junit.BeforeClass; +import org.junit.Test; + +public class StreamToolTest extends SolrCloudTestCase { + + @BeforeClass + public static void setupClusterWithSecurityEnabled() throws Exception { + configureCluster(2).withSecurityJson(SecurityJson.SIMPLE).configure(); + } + + private > T withBasicAuth(T req) { + req.setBasicAuthCredentials(SecurityJson.USER, SecurityJson.PASS); + return req; + } + + @Test + @SuppressWarnings({"unchecked", "rawtypes"}) + public void testGetHeaderFromFirstTuple() { + Tuple tuple = new Tuple(new HashMap()); + tuple.put("field1", "blah"); + tuple.put("field2", "blah"); + tuple.put("field3", "blah"); + + String[] headers = StreamTool.getHeadersFromFirstTuple(tuple); + + assertEquals(headers.length, 3); + assertEquals(headers[0], "field1"); + assertEquals(headers[1], "field2"); + assertEquals(headers[2], "field3"); + } + + @Test + public void testGetOutputFields() { + String[] args = + new String[] { + "--fields", "field9, field2, field3, field4", + }; + StreamTool streamTool = new StreamTool(); + CommandLine cli = SolrCLI.processCommandLineArgs(streamTool, args); + String[] outputFields = StreamTool.getOutputFields(cli); + assert outputFields != null; + assertEquals(outputFields.length, 4); + assertEquals(outputFields[0], "field9"); + assertEquals(outputFields[1], "field2"); + assertEquals(outputFields[2], "field3"); + assertEquals(outputFields[3], "field4"); + } + + @Test + public void testReadExpression() throws Exception { + // This covers parameter substitution and expanded comments support. + + String[] args = {"file.expr", "one", "two", "three"}; + StringWriter stringWriter = new StringWriter(); + PrintWriter buf = new PrintWriter(stringWriter); + buf.println("/*"); + buf.println("Multi-line comment Comment..."); + buf.println("*/"); + buf.println("// Single line comment"); + buf.println("# Single line comment"); + buf.println("let(a=$1, b=$2,"); + buf.println("search($3))"); + buf.println(")"); + + String expr = stringWriter.toString(); + + LineNumberReader reader = new LineNumberReader(new StringReader(expr)); + String finalExpression = StreamTool.readExpression(reader, args); + // Strip the comment and insert the params in order. + assertEquals(finalExpression, "let(a=one, b=two,search(three)))"); + } + + @Test + public void testReadExpression2() throws Exception { + // This covers parameter substitution and expanded comments support. + + String[] args = {"file.expr", "id", "desc_s", "desc"}; + StringWriter stringWriter = new StringWriter(); + PrintWriter buf = new PrintWriter(stringWriter); + + buf.println("# Try me"); + buf.println("search(my_collection,q='*:*',fl='$1, $2',sort='id $3')"); + + String expr = stringWriter.toString(); + + LineNumberReader reader = new LineNumberReader(new StringReader(expr)); + String finalExpression = StreamTool.readExpression(reader, args); + // Strip the comment and insert the params in order. + assertEquals(finalExpression, "search(my_collection,q='*:*',fl='id, desc_s',sort='id desc')"); + } + + @Test + @SuppressWarnings({"unchecked", "rawtypes"}) + public void testReadStream() throws Exception { + StreamTool.StandardInStream inStream = new StreamTool.StandardInStream(); + List tuples = new ArrayList(); + try { + StringWriter stringWriter = new StringWriter(); + PrintWriter buf = new PrintWriter(stringWriter); + + buf.println("one two"); + buf.println("three four"); + buf.println("five six"); + + String expr = stringWriter.toString(); + ByteArrayInputStream inputStream = + new ByteArrayInputStream(expr.getBytes(Charset.defaultCharset())); + inStream.setInputStream(inputStream); + inStream.open(); + while (true) { + Tuple tuple = inStream.read(); + if (tuple.EOF) { + break; + } else { + tuples.add(tuple); + } + } + + } finally { + inStream.close(); + } + + assertEquals(tuples.size(), 3); + + String line1 = tuples.get(0).getString("line"); + String line2 = tuples.get(1).getString("line"); + String line3 = tuples.get(2).getString("line"); + + assertEquals("one two", line1); + assertEquals("three four", line2); + assertEquals("five six", line3); + } + + @Test + @SuppressWarnings({"unchecked", "rawtypes"}) + public void testLocalCatStream() throws Exception { + File localFile = File.createTempFile("topLevel1", ".txt"); + populateFileWithData(localFile.toPath()); + + StreamTool.LocalCatStream catStream = + new StreamTool.LocalCatStream(localFile.getAbsolutePath(), -1); + List tuples = new ArrayList(); + try { + catStream.open(); + while (true) { + Tuple tuple = catStream.read(); + if (tuple.EOF) { + break; + } else { + tuples.add(tuple); + } + } + + } finally { + catStream.close(); + } + + assertEquals(4, tuples.size()); + + for (int i = 0; i < 4; i++) { + Tuple t = tuples.get(i); + assertEquals(localFile.getName() + " line " + (i + 1), t.get("line")); + assertEquals(localFile.getAbsolutePath(), t.get("file")); + } + } + + @Test + @SuppressWarnings({"unchecked", "rawtypes"}) + public void testListToString() { + List stuff = new ArrayList(); + stuff.add("test1"); + stuff.add(3); + stuff.add(111.32322); + stuff.add("test3"); + String s = StreamTool.listToString(stuff, "|"); + assertEquals("test1|3|111.32322|test3", s); + } + + @Test + public void testStdInFailsWithRemoteWorker() throws Exception { + String expression = "echo(stdin())"; + + String[] args = + new String[] { + "stream", + "-e", + "remote", + "--name", + "fakeCollection", + "--verbose", + "--zk-host", + cluster.getZkClient().getZkServerAddress(), + expression + }; + assertEquals(1, runTool(args)); + } + + @Test + public void testStdInSucceedsWithLocalWorker() throws Exception { + String expression = "echo(stdin())"; + + String[] args = + new String[] { + "stream", + "-e", + "local", + "-v", + "-z", + cluster.getZkClient().getZkServerAddress(), + expression + }; + assertEquals(0, runTool(args)); + } + + @Test + public void testRunEchoStreamLocally() throws Exception { + + String expression = "echo(Hello)"; + File expressionFile = File.createTempFile("expression", ".EXPR"); + FileWriter writer = new FileWriter(expressionFile, Charset.defaultCharset()); + writer.write(expression); + writer.close(); + + // test passing in the file + // notice that we do not pass in zkHost or solrUrl for a simple echo run locally. + String[] args = { + "stream", + "-e", + "local", + "--verbose", + "-zk-host", + cluster.getZkClient().getZkServerAddress(), + expressionFile.getAbsolutePath() + }; + + assertEquals(0, runTool(args)); + + // test passing in the expression directly + args = + new String[] { + "stream", + "--execution", + "local", + "--verbose", + "--zk-host", + cluster.getZkClient().getZkServerAddress(), + expression + }; + + assertEquals(0, runTool(args)); + } + + @Test + public void testRunEchoStreamRemotely() throws Exception { + String collectionName = "streamWorkerCollection"; + withBasicAuth(CollectionAdminRequest.createCollection(collectionName, "_default", 1, 1)) + .processAndWait(cluster.getSolrClient(), 10); + waitForState( + "Expected collection to be created with 1 shard and 1 replicas", + collectionName, + clusterShape(1, 1)); + + String expression = "echo(Hello)"; + File expressionFile = File.createTempFile("expression", ".EXPR"); + FileWriter writer = new FileWriter(expressionFile, Charset.defaultCharset()); + writer.write(expression); + writer.close(); + + // test passing in the file + String[] args = { + "stream", + "-e", + "remote", + "-c", + collectionName, + "--verbose", + "-z", + cluster.getZkClient().getZkServerAddress(), + "--credentials", + SecurityJson.USER_PASS, + expressionFile.getAbsolutePath() + }; + + assertEquals(0, runTool(args)); + + // test passing in the expression directly + args = + new String[] { + "stream", + "--execution", + "remote", + "--name", + collectionName, + "--verbose", + "--zk-host", + cluster.getZkClient().getZkServerAddress(), + "--credentials", + SecurityJson.USER_PASS, + expression + }; + + assertEquals(0, runTool(args)); + } + + private int runTool(String[] args) throws Exception { + Tool tool = findTool(args); + assertTrue(tool instanceof StreamTool); + CommandLine cli = parseCmdLine(tool, args); + return tool.runTool(cli); + } + + // Copied from StreamExpressionTest.java + private static void populateFileWithData(Path dataFile) throws Exception { + // Files.createFile(dataFile); + try (final BufferedWriter writer = Files.newBufferedWriter(dataFile, StandardCharsets.UTF_8)) { + for (int i = 1; i <= 4; i++) { + writer.write(dataFile.getFileName() + " line " + i); + writer.newLine(); + } + } + } +} diff --git a/solr/packaging/test/test_stream.bats b/solr/packaging/test/test_stream.bats new file mode 100644 index 00000000000..63145522c79 --- /dev/null +++ b/solr/packaging/test/test_stream.bats @@ -0,0 +1,86 @@ +#!/usr/bin/env bats + +# 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. + +load bats_helper + +setup_file() { + common_clean_setup + solr start -e techproducts + solr auth enable --type basicAuth --credentials name:password +} + +teardown_file() { + common_setup + solr stop --all +} + +setup() { + common_setup +} + +teardown() { + # save a snapshot of SOLR_HOME for failed tests + save_home_on_failure +} + +@test "searching solr via locally executed streaming expression" { + + local solr_stream_file="${BATS_TEST_TMPDIR}/search.expr" + echo 'search(techproducts,' > "${solr_stream_file}" + echo 'q="name:memory",' >> "${solr_stream_file}" + echo 'fl="name,price",' >> "${solr_stream_file}" + echo 'sort="price desc"' >> "${solr_stream_file}" + echo ')' >> "${solr_stream_file}" + + run solr stream --execution local --header --credentials name:password ${solr_stream_file} + + assert_output --partial 'name price' + assert_output --partial 'CORSAIR XMS' + refute_output --partial 'ERROR' +} + +@test "searching solr via remotely executed streaming expression" { + + local solr_stream_file="${BATS_TEST_TMPDIR}/search.expr" + echo 'search(techproducts,' > "${solr_stream_file}" + echo 'q="name:memory",' >> "${solr_stream_file}" + echo 'fl="name,price",' >> "${solr_stream_file}" + echo 'sort="price desc"' >> "${solr_stream_file}" + echo ')' >> "${solr_stream_file}" + + run solr stream -e remote --name techproducts --solr-url http://localhost:${SOLR_PORT} --header --credentials name:password ${solr_stream_file} + + assert_output --partial 'name price' + assert_output --partial 'CORSAIR XMS' + refute_output --partial 'ERROR' +} + +@test "variable interpolation" { + + local solr_stream_file="${BATS_TEST_TMPDIR}/search.expr" + echo 'search(techproducts,' > "${solr_stream_file}" + echo 'q="name:$1",' >> "${solr_stream_file}" + echo 'fl="name,price",' >> "${solr_stream_file}" + echo 'sort="price $2"' >> "${solr_stream_file}" + echo ')' >> "${solr_stream_file}" + + run solr stream --execution local --header --credentials name:password ${solr_stream_file} apple asc + + assert_output --partial 'name price' + assert_output --partial 'Apple 60 GB iPod' + refute_output --partial 'ERROR' +} diff --git a/solr/solr-ref-guide/modules/query-guide/pages/stream-tool.adoc b/solr/solr-ref-guide/modules/query-guide/pages/stream-tool.adoc new file mode 100644 index 00000000000..20fe2458e42 --- /dev/null +++ b/solr/solr-ref-guide/modules/query-guide/pages/stream-tool.adoc @@ -0,0 +1,176 @@ += Stream Tool +// 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. + +The Stream tool allows you to run a xref:streaming-expressions.adoc[] in Solr and see the results from the command line. +It is very similar to the xref:stream-screen.adoc[], but is part of the `bin/solr` CLI. +Being a CLI, you can pipe content into it similar to other Unix style tools, as well as run actually RUN many kinds of expressions locally as well. + +NOTE: The Stream Tool is classified as "experimental". +It may change in backwards-incompatible ways as it evolves to cover additional functionality. + +To run it, open a terminal and enter: + +[,console] +---- +$ bin/solr stream --header -c techproducts --delimiter=\| 'search(techproducts,q="name:memory",fl="name,price")' +---- + +This will run the provided streaming expression on the `techproducts` collection on your local Solr and produce: + +[,console] +---- +name|price +CORSAIR XMS 2GB (2 x 1GB) 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) Dual Channel Kit System Memory - Retail|185.0 +CORSAIR ValueSelect 1GB 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) System Memory - Retail|74.99 +A-DATA V-Series 1GB 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) System Memory - OEM| +---- + +TIP: Notice how we used the pipe character (|) as the delimiter? It required a backslash for escaping it so it wouldn't be treated as a pipe within the shell script. + +You can also specify a file with the suffix `.expr` containing your streaming expression. +This is useful for longer expressions or if you are experiencing shell character-escaping issues with your expression. + +Assuming you have create the file `stream.expr` with the contents: + +---- +# Stream a search + +search( + techproducts, + q="name:memory", + fl="name,price", + sort="price desc" +) +---- + +Then you can run it on the Solr collection `techproducts`, specifying you want a header row: + +[,console] +---- +$ bin/solr stream --header -c techproducts stream.expr +---- + +And this will produce: + +[,console] +---- +name price +CORSAIR XMS 2GB (2 x 1GB) 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) Dual Channel Kit System Memory - Retail 185.0 +CORSAIR ValueSelect 1GB 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) System Memory - Retail 74.99 +A-DATA V-Series 1GB 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) System Memory - OEM +---- + +== Using the bin/solr stream Tool + +To use the tool you need to provide the streaming expression either inline as the last argument, or provide a file ending in `.expr` that contains the expression. + +The `--help` (or simply `-h`) option will output information on its usage (i.e., `bin/solr stream --help)`: + +[source,plain] +---- +usage: bin/solr stream [--array-delimiter ] [-c ] [--delimiter ] [-e ] [-f + ] [-h] [--header] [-s ] [-u ] [-v] [-z ] + +List of options: + --array-delimiter The delimiter multi-valued fields. Default to using a pipe (|) delimiter. + -c,--name Name of the specific collection to execute expression on if the execution is set + to 'remote'. Required for 'remote' execution environment. + --delimiter The output delimiter. Default to using three spaces. + -e,--execution Execution environment is either 'local' (i.e CLI process) or via a 'remote' Solr + server. Default environment is 'remote'. + -f,--fields The fields in the tuples to output. Defaults to fields in the first tuple of result + set. + -h,--help Print this message. + --header Specify to include a header line. + -s,--solr-url Base Solr URL, which can be used to determine the zk-host if that's not known; + defaults to: http://localhost:8983. + -u,--credentials Credentials in the format username:password. Example: --credentials solr:SolrRocks + -v,--verbose Enable verbose command output. + -z,--zk-host Zookeeper connection string; unnecessary if ZK_HOST is defined in solr.in.sh; + otherwise, defaults to localhost:9983. +---- + +== Examples Using bin/solr stream + +There are several ways to use `bin/solr stream`. +This section presents several examples. + +=== Executing Expression Locally + +Streaming Expressions by default are executed in the Solr cluster. +However there are use cases where you want to interact with data in your local environment, or even run a streaming expression independent of Solr. + +The Stream Tool allows you to specify `--execution local` to process the expression in the Solr CLI's JVM. + +However, "local" processing does not imply a networking sandbox. +Many streaming expressions, such as `search` and `update`, will make network requests to remote Solr nodes if configured to do so, even in "local" execution mode. + +Assuming you have create the file `load_data.expr` with the contents: + +---- +# Index CSV File + +update( + gettingstarted, + parseCSV( + cat(./example/exampledocs/books.csv, maxLines=2) + ) +) +---- + +Running this expression will read in the local file and send the first two lines to the collection `gettingstarted`. + +TIP: Want to send data to a remote Solr? pass in `--solr-url http://solr.remote:8983`. + + +[,console] +---- +$ bin/solr stream --execution local --header load_data.expr +---- + + +The StreamTool adds some Streaming Expressions specifically for local use: + +* stdin() lets you pipe data directly into the streaming expression. +* cat() that allows you to read ANY file on your local system. This is different from the xref:stream-source-reference.adoc#cat[`cat`] operator that runs in Solr that only accesses `$SOLR_HOME/userfiles/`. + +Caveats: + + * You don't get to use any of the parallelization support that is available when you run the expression on the cluster. + * Anything that requires Solr internals access won't work with the `--execution local` context. + +=== Piping data to an expression + +Index a CSV file into `gettingstarted` collection. + +[,console] +---- +$ cat example/exampledocs/books.csv | bin/solr stream -e local 'update(gettingstarted,parseCSV(stdin()))' +---- + +=== Variable interpolation + +You can do variable interpolation via having `$1`, `$2` etc in your streaming expression, and then passing those values as arguments. + +[,console] +---- +$ bin/solr stream -c techproducts 'echo("$1")' "Hello World" +Hello World +---- + +This also works when using `.expr` files. diff --git a/solr/solr-ref-guide/modules/query-guide/pages/streaming-expressions.adoc b/solr/solr-ref-guide/modules/query-guide/pages/streaming-expressions.adoc index a9a6bf564aa..cc3e502a2bc 100644 --- a/solr/solr-ref-guide/modules/query-guide/pages/streaming-expressions.adoc +++ b/solr/solr-ref-guide/modules/query-guide/pages/streaming-expressions.adoc @@ -143,3 +143,7 @@ The xref:math-expressions.adoc[] has in depth coverage of visualization techniqu === Stream Screen * xref:stream-screen.adoc[]: Submit streaming expressions and see results and parsing explanations. + +=== Stream Tool + +* xref:stream-tool.adoc[]: Submit streaming expressions and see results via `bin/solr stream`. diff --git a/solr/solr-ref-guide/modules/query-guide/querying-nav.adoc b/solr/solr-ref-guide/modules/query-guide/querying-nav.adoc index aa3f0fbade7..973bd80f005 100644 --- a/solr/solr-ref-guide/modules/query-guide/querying-nav.adoc +++ b/solr/solr-ref-guide/modules/query-guide/querying-nav.adoc @@ -96,3 +96,4 @@ ** xref:graph-traversal.adoc[] ** xref:stream-api.adoc[] ** xref:stream-screen.adoc[] +** xref:stream-tool.adoc[] diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/SolrClientCache.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/SolrClientCache.java index 45ce93c30c4..7550d1a35c4 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/SolrClientCache.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/SolrClientCache.java @@ -17,7 +17,6 @@ package org.apache.solr.client.solrj.io; import java.io.Closeable; -import java.lang.invoke.MethodHandles; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -38,14 +37,10 @@ import org.apache.solr.common.AlreadyClosedException; import org.apache.solr.common.util.IOUtils; import org.apache.solr.common.util.URLUtil; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; /** The SolrClientCache caches SolrClients, so they can be reused by different TupleStreams. */ public class SolrClientCache implements Closeable { - private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass()); - // Set the floor for timeouts to 60 seconds. // Timeouts can be increased by setting the system properties defined below. private static final int MIN_TIMEOUT = 60000; @@ -55,6 +50,8 @@ public class SolrClientCache implements Closeable { private static final int minSocketTimeout = Math.max(Integer.getInteger(HttpClientUtil.PROP_SO_TIMEOUT, MIN_TIMEOUT), MIN_TIMEOUT); + private String basicAuthCredentials = null; // Only support with the http2SolrClient + private final Map solrClients = new HashMap<>(); private final HttpClient apacheHttpClient; private final Http2SolrClient http2SolrClient; @@ -77,6 +74,10 @@ public SolrClientCache(Http2SolrClient http2SolrClient) { this.http2SolrClient = http2SolrClient; } + public void setBasicAuthCredentials(String basicAuthCredentials) { + this.basicAuthCredentials = basicAuthCredentials; + } + public void setDefaultZKHost(String zkHost) { if (zkHost != null) { zkHost = zkHost.split("/")[0]; @@ -101,11 +102,12 @@ public synchronized CloudSolrClient getCloudSolrClient(String zkHost) { String zkHostNoChroot = zkHost.split("/")[0]; boolean canUseACLs = Optional.ofNullable(defaultZkHost.get()).map(zkHostNoChroot::equals).orElse(false); + final CloudSolrClient client; if (apacheHttpClient != null) { client = newCloudLegacySolrClient(zkHost, apacheHttpClient, canUseACLs); } else { - client = newCloudHttp2SolrClient(zkHost, http2SolrClient, canUseACLs); + client = newCloudHttp2SolrClient(zkHost, http2SolrClient, canUseACLs, basicAuthCredentials); } solrClients.put(zkHost, client); return client; @@ -129,12 +131,17 @@ private static CloudSolrClient newCloudLegacySolrClient( } private static CloudHttp2SolrClient newCloudHttp2SolrClient( - String zkHost, Http2SolrClient http2SolrClient, boolean canUseACLs) { + String zkHost, + Http2SolrClient http2SolrClient, + boolean canUseACLs, + String basicAuthCredentials) { final List hosts = List.of(zkHost); var builder = new CloudHttp2SolrClient.Builder(hosts, Optional.empty()); builder.canUseZkACLs(canUseACLs); // using internal builder to ensure the internal client gets closed - builder = builder.withInternalClientBuilder(newHttp2SolrClientBuilder(null, http2SolrClient)); + builder = + builder.withInternalClientBuilder( + newHttp2SolrClientBuilder(null, http2SolrClient, basicAuthCredentials)); var client = builder.build(); try { client.connect(); @@ -163,7 +170,7 @@ public synchronized SolrClient getHttpSolrClient(String baseUrl) { if (apacheHttpClient != null) { client = newHttpSolrClient(baseUrl, apacheHttpClient); } else { - client = newHttp2SolrClientBuilder(baseUrl, http2SolrClient).build(); + client = newHttp2SolrClientBuilder(baseUrl, http2SolrClient, basicAuthCredentials).build(); } solrClients.put(baseUrl, client); return client; @@ -190,7 +197,7 @@ private static void adjustTimeouts(SolrClientBuilder builder, HttpClient http } private static Http2SolrClient.Builder newHttp2SolrClientBuilder( - String url, Http2SolrClient http2SolrClient) { + String url, Http2SolrClient http2SolrClient, String basicAuthCredentials) { final var builder = (url == null || URLUtil.isBaseUrl(url)) // URL may be null here and set by caller ? new Http2SolrClient.Builder(url) @@ -199,6 +206,8 @@ private static Http2SolrClient.Builder newHttp2SolrClientBuilder( if (http2SolrClient != null) { builder.withHttpClient(http2SolrClient); } + builder.withOptionalBasicAuthCredentials(basicAuthCredentials); + long idleTimeout = minSocketTimeout; if (builder.getIdleTimeoutMillis() != null) { idleTimeout = Math.max(idleTimeout, builder.getIdleTimeoutMillis()); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/LetStream.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/LetStream.java index 9576cf9658e..fc26a8972f7 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/LetStream.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/LetStream.java @@ -224,4 +224,9 @@ public StreamComparator getStreamSort() { public int getCost() { return 0; } + + @SuppressWarnings({"rawtypes"}) + public Map getLetParams() { + return this.letParams; + } } From 9f591aaea1d86127ab06850c16d951333267f78f Mon Sep 17 00:00:00 2001 From: Kevin Risden Date: Wed, 13 Nov 2024 15:53:51 -0500 Subject: [PATCH 03/33] SOLR-17545: Fix alternative jdk testing support (#2864) --- gradle/testing/alternative-jdk-support.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle/testing/alternative-jdk-support.gradle b/gradle/testing/alternative-jdk-support.gradle index a1ff1b4b014..97e5311ee09 100644 --- a/gradle/testing/alternative-jdk-support.gradle +++ b/gradle/testing/alternative-jdk-support.gradle @@ -50,7 +50,7 @@ if (jvmGradle != jvmCurrent) { doFirst { def jvmInfo = { JavaInfo javaInfo -> - JvmInstallationMetadata jvmMetadata = jvmDetector.getMetadata(new InstallationLocation(javaInfo.javaHome, "specific path")) + JvmInstallationMetadata jvmMetadata = jvmDetector.getMetadata(InstallationLocation.userDefined(javaInfo.javaHome, "specific path")) return "${jvmMetadata.languageVersion} (${jvmMetadata.displayName} ${jvmMetadata.runtimeVersion}, home at: ${jvmMetadata.javaHome})" } From 24fe19177bc0ffe29d4ddcf8857ac83f57e0f58b Mon Sep 17 00:00:00 2001 From: David Smiley Date: Wed, 13 Nov 2024 17:28:22 -0500 Subject: [PATCH 04/33] SOLR-17535: Migrate ClusterState.getCollectionsMap callers to Stream (#2846) Deprecated getCollectionsMap. A refactoring, albeit some additional points: * DeleteCollection: avoid NPE for non-existent collection (trivial change) * ClusterStateUtil (test-framework): optimize waiting to use ZkStateReader.waitForState for single-collection --- .../org/apache/solr/cloud/ConfigSetCmds.java | 23 +- .../cloud/DistributedClusterStateUpdater.java | 2 +- .../api/collections/DeleteCollectionCmd.java | 16 +- .../collections/ReplicaMigrationUtils.java | 36 +-- .../solr/cloud/overseer/NodeMutator.java | 29 +- .../maintenance/InactiveShardRemover.java | 3 +- .../impl/SimpleClusterAbstractionsImpl.java | 3 +- .../solr/handler/admin/ClusterStatus.java | 121 ++++---- .../handler/admin/api/ListCollections.java | 17 +- .../org/apache/solr/servlet/HttpSolrCall.java | 43 +-- .../solr/cloud/CollectionsAPISolrJTest.java | 9 +- .../org/apache/solr/cloud/OverseerTest.java | 18 +- ...aredFileSystemAutoReplicaFailoverTest.java | 52 +--- .../prometheus/scraper/SolrCloudScraper.java | 10 +- .../scraper/SolrCloudScraperTest.java | 10 +- .../solr/common/cloud/ClusterState.java | 6 +- .../cloud/AbstractFullDistribZkTestBase.java | 8 +- .../solr/common/cloud/ClusterStateUtil.java | 289 +++++++----------- 18 files changed, 291 insertions(+), 404 deletions(-) diff --git a/solr/core/src/java/org/apache/solr/cloud/ConfigSetCmds.java b/solr/core/src/java/org/apache/solr/cloud/ConfigSetCmds.java index ee1c01f99d4..52219bbc2ea 100644 --- a/solr/core/src/java/org/apache/solr/cloud/ConfigSetCmds.java +++ b/solr/core/src/java/org/apache/solr/cloud/ConfigSetCmds.java @@ -31,7 +31,6 @@ import java.util.HashMap; import java.util.Map; import org.apache.solr.common.SolrException; -import org.apache.solr.common.cloud.DocCollection; import org.apache.solr.common.cloud.ZkNodeProps; import org.apache.solr.common.cloud.ZkStateReader; import org.apache.solr.common.params.ConfigSetParams; @@ -184,16 +183,18 @@ private static void deleteConfigSet( String configSetName, boolean force, CoreContainer coreContainer) throws IOException { ZkStateReader zkStateReader = coreContainer.getZkController().getZkStateReader(); - for (Map.Entry entry : - zkStateReader.getClusterState().getCollectionsMap().entrySet()) { - String configName = entry.getValue().getConfigName(); - if (configSetName.equals(configName)) - throw new SolrException( - SolrException.ErrorCode.BAD_REQUEST, - "Can not delete ConfigSet as it is currently being used by collection [" - + entry.getKey() - + "]"); - } + zkStateReader + .getClusterState() + .forEachCollection( + state -> { + String configName = state.getConfigName(); + if (configSetName.equals(configName)) + throw new SolrException( + SolrException.ErrorCode.BAD_REQUEST, + "Can not delete ConfigSet as it is currently being used by collection [" + + state.getName() + + "]"); + }); String propertyPath = ConfigSetProperties.DEFAULT_FILENAME; NamedList properties = diff --git a/solr/core/src/java/org/apache/solr/cloud/DistributedClusterStateUpdater.java b/solr/core/src/java/org/apache/solr/cloud/DistributedClusterStateUpdater.java index 7d47dd26bcb..3c7552790c9 100644 --- a/solr/core/src/java/org/apache/solr/cloud/DistributedClusterStateUpdater.java +++ b/solr/core/src/java/org/apache/solr/cloud/DistributedClusterStateUpdater.java @@ -975,7 +975,7 @@ public void computeUpdates(ClusterState clusterState, SolrZkClient client) { final DocCollection docCollection = clusterState.getCollectionOrNull(collectionName); Optional result = docCollection != null - ? NodeMutator.computeCollectionUpdate(nodeName, collectionName, docCollection, client) + ? NodeMutator.computeCollectionUpdate(nodeName, docCollection, client) : Optional.empty(); if (docCollection == null) { diff --git a/solr/core/src/java/org/apache/solr/cloud/api/collections/DeleteCollectionCmd.java b/solr/core/src/java/org/apache/solr/cloud/api/collections/DeleteCollectionCmd.java index a1e9012aaf0..1d8629c4fdc 100644 --- a/solr/core/src/java/org/apache/solr/cloud/api/collections/DeleteCollectionCmd.java +++ b/solr/core/src/java/org/apache/solr/cloud/api/collections/DeleteCollectionCmd.java @@ -168,21 +168,19 @@ public void call(ClusterState state, ZkNodeProps message, NamedList resu } // delete related config set iff: it is auto generated AND not related to any other collection - String configSetName = coll.getConfigName(); + String configSetName = coll == null ? null : coll.getConfigName(); if (ConfigSetsHandler.isAutoGeneratedConfigSet(configSetName)) { boolean configSetIsUsedByOtherCollection = false; // make sure the configSet is not shared with other collections // Similar to what happens in: ConfigSetCmds::deleteConfigSet - for (Map.Entry entry : - zkStateReader.getClusterState().getCollectionsMap().entrySet()) { - String otherConfigSetName = entry.getValue().getConfigName(); - if (configSetName.equals(otherConfigSetName)) { - configSetIsUsedByOtherCollection = true; - break; - } - } + configSetIsUsedByOtherCollection = + zkStateReader + .getClusterState() + .collectionStream() + .map(DocCollection::getConfigName) + .anyMatch(configSetName::equals); if (!configSetIsUsedByOtherCollection) { // delete the config set diff --git a/solr/core/src/java/org/apache/solr/cloud/api/collections/ReplicaMigrationUtils.java b/solr/core/src/java/org/apache/solr/cloud/api/collections/ReplicaMigrationUtils.java index 6013dea0c2d..d21aa3a5f95 100644 --- a/solr/core/src/java/org/apache/solr/cloud/api/collections/ReplicaMigrationUtils.java +++ b/solr/core/src/java/org/apache/solr/cloud/api/collections/ReplicaMigrationUtils.java @@ -34,9 +34,7 @@ import org.apache.solr.common.SolrCloseableLatch; import org.apache.solr.common.cloud.ClusterState; import org.apache.solr.common.cloud.CollectionStateWatcher; -import org.apache.solr.common.cloud.DocCollection; import org.apache.solr.common.cloud.Replica; -import org.apache.solr.common.cloud.Slice; import org.apache.solr.common.cloud.ZkNodeProps; import org.apache.solr.common.cloud.ZkStateReader; import org.apache.solr.common.params.CoreAdminParams; @@ -305,30 +303,20 @@ static boolean cleanupReplicas( } static List getReplicasOfNodes(Collection nodeNames, ClusterState state) { - List sourceReplicas = new ArrayList<>(); - for (Map.Entry e : state.getCollectionsMap().entrySet()) { - for (Slice slice : e.getValue().getSlices()) { - for (Replica replica : slice.getReplicas()) { - if (nodeNames.contains(replica.getNodeName())) { - sourceReplicas.add(replica); - } - } - } - } - return sourceReplicas; + return state + .collectionStream() + .flatMap(dc -> dc.getSlices().stream()) + .flatMap(s -> s.getReplicas().stream()) + .filter(r -> nodeNames.contains(r.getNodeName())) + .toList(); } static List getReplicasOfNode(String nodeName, ClusterState state) { - List sourceReplicas = new ArrayList<>(); - for (Map.Entry e : state.getCollectionsMap().entrySet()) { - for (Slice slice : e.getValue().getSlices()) { - for (Replica replica : slice.getReplicas()) { - if (nodeName.equals(replica.getNodeName())) { - sourceReplicas.add(replica); - } - } - } - } - return sourceReplicas; + return state + .collectionStream() + .flatMap(dc -> dc.getSlices().stream()) + .flatMap(s -> s.getReplicas().stream()) + .filter(r -> nodeName.equals(r.getNodeName())) + .toList(); } } diff --git a/solr/core/src/java/org/apache/solr/cloud/overseer/NodeMutator.java b/solr/core/src/java/org/apache/solr/cloud/overseer/NodeMutator.java index f54d2569ef5..48ce2e9fde2 100644 --- a/solr/core/src/java/org/apache/solr/cloud/overseer/NodeMutator.java +++ b/solr/core/src/java/org/apache/solr/cloud/overseer/NodeMutator.java @@ -49,23 +49,12 @@ public List downNode(ClusterState clusterState, ZkNodeProps mess log.debug("DownNode state invoked for node: {}", nodeName); - List zkWriteCommands = new ArrayList<>(); - - Map collections = clusterState.getCollectionsMap(); - for (Map.Entry entry : collections.entrySet()) { - String collectionName = entry.getKey(); - DocCollection docCollection = entry.getValue(); - if (docCollection.isPerReplicaState()) continue; - - Optional zkWriteCommand = - computeCollectionUpdate(nodeName, collectionName, docCollection, zkClient); - - if (zkWriteCommand.isPresent()) { - zkWriteCommands.add(zkWriteCommand.get()); - } - } - - return zkWriteCommands; + return clusterState + .collectionStream() + .filter(entry -> !entry.isPerReplicaState()) + .map(docCollection -> computeCollectionUpdate(nodeName, docCollection, zkClient)) + .flatMap(Optional::stream) + .toList(); } /** @@ -77,7 +66,7 @@ public List downNode(ClusterState clusterState, ZkNodeProps mess * for an update to state.json, depending on the configuration of the collection. */ public static Optional computeCollectionUpdate( - String nodeName, String collectionName, DocCollection docCollection, SolrZkClient client) { + String nodeName, DocCollection docCollection, SolrZkClient client) { boolean needToUpdateCollection = false; List downedReplicas = new ArrayList<>(); final Map slicesCopy = new LinkedHashMap<>(docCollection.getSlicesMap()); @@ -107,13 +96,13 @@ public static Optional computeCollectionUpdate( return Optional.of( new ZkWriteCommand( - collectionName, + docCollection.getName(), docCollection.copyWithSlices(slicesCopy), PerReplicaStatesOps.downReplicas(downedReplicas, prs), false)); } else { return Optional.of( - new ZkWriteCommand(collectionName, docCollection.copyWithSlices(slicesCopy))); + new ZkWriteCommand(docCollection.getName(), docCollection.copyWithSlices(slicesCopy))); } } else { // No update needed for this collection diff --git a/solr/core/src/java/org/apache/solr/cluster/maintenance/InactiveShardRemover.java b/solr/core/src/java/org/apache/solr/cluster/maintenance/InactiveShardRemover.java index 177663d1140..1d951492afd 100644 --- a/solr/core/src/java/org/apache/solr/cluster/maintenance/InactiveShardRemover.java +++ b/solr/core/src/java/org/apache/solr/cluster/maintenance/InactiveShardRemover.java @@ -143,7 +143,8 @@ public void stop() { void deleteInactiveSlices() { final ClusterState clusterState = coreContainer.getZkController().getClusterState(); Collection inactiveSlices = - clusterState.getCollectionsMap().values().stream() + clusterState + .collectionStream() .flatMap(v -> collectInactiveSlices(v).stream()) .collect(Collectors.toSet()); diff --git a/solr/core/src/java/org/apache/solr/cluster/placement/impl/SimpleClusterAbstractionsImpl.java b/solr/core/src/java/org/apache/solr/cluster/placement/impl/SimpleClusterAbstractionsImpl.java index cb86dc304e5..ece890b9b1f 100644 --- a/solr/core/src/java/org/apache/solr/cluster/placement/impl/SimpleClusterAbstractionsImpl.java +++ b/solr/core/src/java/org/apache/solr/cluster/placement/impl/SimpleClusterAbstractionsImpl.java @@ -93,7 +93,8 @@ public SolrCollection getCollection(String collectionName) { @Override public Iterator iterator() { - return clusterState.getCollectionsMap().values().stream() + return clusterState + .collectionStream() .map(SolrCollectionImpl::fromDocCollection) .collect(Collectors.toSet()) .iterator(); diff --git a/solr/core/src/java/org/apache/solr/handler/admin/ClusterStatus.java b/solr/core/src/java/org/apache/solr/handler/admin/ClusterStatus.java index 6c5998d17a2..18c8843f916 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/ClusterStatus.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/ClusterStatus.java @@ -24,8 +24,9 @@ import java.util.HashSet; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Set; -import java.util.stream.Collectors; +import java.util.stream.Stream; import org.apache.solr.common.SolrException; import org.apache.solr.common.cloud.Aliases; import org.apache.solr.common.cloud.ClusterState; @@ -43,6 +44,7 @@ import org.apache.zookeeper.KeeperException; public class ClusterStatus { + private final ZkStateReader zkStateReader; private final SolrParams solrParams; private final String collection; // maybe null @@ -178,79 +180,74 @@ private void fetchClusterStatusForCollOrAlias( String routeKey = solrParams.get(ShardParams._ROUTE_); String shard = solrParams.get(ZkStateReader.SHARD_ID_PROP); - Map collectionsMap = null; + Stream collectionStream; if (collection == null) { - collectionsMap = clusterState.getCollectionsMap(); + collectionStream = clusterState.collectionStream(); } else { - collectionsMap = - Collections.singletonMap(collection, clusterState.getCollectionOrNull(collection)); - } - - boolean isAlias = aliasVsCollections.containsKey(collection); - boolean didNotFindCollection = collectionsMap.get(collection) == null; - - if (didNotFindCollection && isAlias) { - // In this case this.collection is an alias name not a collection - // get all collections and filter out collections not in the alias - // clusterState.getCollectionsMap() should be replaced with an inexpensive call - collectionsMap = - clusterState.getCollectionsMap().entrySet().stream() - .filter((entry) -> aliasVsCollections.get(collection).contains(entry.getKey())) - .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); - } - - NamedList collectionProps = new SimpleOrderedMap<>(); - - for (Map.Entry entry : collectionsMap.entrySet()) { - Map collectionStatus; - String name = entry.getKey(); - DocCollection clusterStateCollection = entry.getValue(); - if (clusterStateCollection == null) { - if (collection != null) { + DocCollection collState = clusterState.getCollectionOrNull(collection); + if (collState != null) { + collectionStream = Stream.of(collState); + } else { // couldn't find collection + // hopefully an alias... + if (!aliasVsCollections.containsKey(collection)) { // not an alias either SolrException solrException = new SolrException( - SolrException.ErrorCode.BAD_REQUEST, "Collection: " + name + " not found"); + SolrException.ErrorCode.BAD_REQUEST, "Collection: " + collection + " not found"); solrException.setMetadata("CLUSTERSTATUS", "NOT_FOUND"); throw solrException; - } else { - // collection might have got deleted at the same time - continue; } + // In this case this.collection is an alias name not a collection + // Resolve them (not recursively but maybe should?). + collectionStream = + aliasVsCollections.get(collection).stream() + .map(clusterState::getCollectionOrNull) + .filter(Objects::nonNull); } + } - Set requestedShards = new HashSet<>(); - if (routeKey != null) { - DocRouter router = clusterStateCollection.getRouter(); - Collection slices = router.getSearchSlices(routeKey, null, clusterStateCollection); - for (Slice slice : slices) { - requestedShards.add(slice.getName()); - } - } - if (shard != null) { - String[] paramShards = shard.split(","); - requestedShards.addAll(Arrays.asList(paramShards)); - } + // TODO use an Iterable to stream the data to the client instead of gathering it all in mem - byte[] bytes = Utils.toJSON(clusterStateCollection); - @SuppressWarnings("unchecked") - Map docCollection = (Map) Utils.fromJSON(bytes); - collectionStatus = getCollectionStatus(docCollection, name, requestedShards); + NamedList collectionProps = new SimpleOrderedMap<>(); - collectionStatus.put("znodeVersion", clusterStateCollection.getZNodeVersion()); - collectionStatus.put( - "creationTimeMillis", clusterStateCollection.getCreationTime().toEpochMilli()); + collectionStream.forEach( + clusterStateCollection -> { + Map collectionStatus; + String name = clusterStateCollection.getName(); + + Set requestedShards = new HashSet<>(); + if (routeKey != null) { + DocRouter router = clusterStateCollection.getRouter(); + Collection slices = + router.getSearchSlices(routeKey, null, clusterStateCollection); + for (Slice slice : slices) { + requestedShards.add(slice.getName()); + } + } + if (shard != null) { + String[] paramShards = shard.split(","); + requestedShards.addAll(Arrays.asList(paramShards)); + } - if (collectionVsAliases.containsKey(name) && !collectionVsAliases.get(name).isEmpty()) { - collectionStatus.put("aliases", collectionVsAliases.get(name)); - } - String configName = clusterStateCollection.getConfigName(); - collectionStatus.put("configName", configName); - if (solrParams.getBool("prs", false) && clusterStateCollection.isPerReplicaState()) { - PerReplicaStates prs = clusterStateCollection.getPerReplicaStates(); - collectionStatus.put("PRS", prs); - } - collectionProps.add(name, collectionStatus); - } + byte[] bytes = Utils.toJSON(clusterStateCollection); + @SuppressWarnings("unchecked") + Map docCollection = (Map) Utils.fromJSON(bytes); + collectionStatus = getCollectionStatus(docCollection, name, requestedShards); + + collectionStatus.put("znodeVersion", clusterStateCollection.getZNodeVersion()); + collectionStatus.put( + "creationTimeMillis", clusterStateCollection.getCreationTime().toEpochMilli()); + + if (collectionVsAliases.containsKey(name) && !collectionVsAliases.get(name).isEmpty()) { + collectionStatus.put("aliases", collectionVsAliases.get(name)); + } + String configName = clusterStateCollection.getConfigName(); + collectionStatus.put("configName", configName); + if (solrParams.getBool("prs", false) && clusterStateCollection.isPerReplicaState()) { + PerReplicaStates prs = clusterStateCollection.getPerReplicaStates(); + collectionStatus.put("PRS", prs); + } + collectionProps.add(name, collectionStatus); + }); // now we need to walk the collectionProps tree to cross-check replica state with live nodes crossCheckReplicaStateWithLiveNodes(liveNodes, collectionProps); diff --git a/solr/core/src/java/org/apache/solr/handler/admin/api/ListCollections.java b/solr/core/src/java/org/apache/solr/handler/admin/api/ListCollections.java index 4b54b86ae81..81c5fac32c5 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/api/ListCollections.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/api/ListCollections.java @@ -20,10 +20,7 @@ import static org.apache.solr.security.PermissionNameProvider.Name.COLL_READ_PERM; import jakarta.inject.Inject; -import java.util.ArrayList; -import java.util.Collections; import java.util.List; -import java.util.Map; import org.apache.solr.client.api.endpoint.ListCollectionsApi; import org.apache.solr.client.api.model.ListCollectionsResponse; import org.apache.solr.common.cloud.DocCollection; @@ -51,10 +48,16 @@ public ListCollectionsResponse listCollections() { instantiateJerseyResponse(ListCollectionsResponse.class); validateZooKeeperAwareCoreContainer(coreContainer); - Map collections = - coreContainer.getZkController().getZkStateReader().getClusterState().getCollectionsMap(); - List collectionList = new ArrayList<>(collections.keySet()); - Collections.sort(collectionList); + // resolve each name to ensure it exists. + // TODO https://issues.apache.org/jira/browse/SOLR-16909 to go direct to ZK? + List collectionList = + coreContainer + .getZkController() + .getClusterState() + .collectionStream() + .map(DocCollection::getName) + .sorted() + .toList(); // XXX should we add aliases here? response.collections = collectionList; diff --git a/solr/core/src/java/org/apache/solr/servlet/HttpSolrCall.java b/solr/core/src/java/org/apache/solr/servlet/HttpSolrCall.java index 99291fc6ad0..7241be77390 100644 --- a/solr/core/src/java/org/apache/solr/servlet/HttpSolrCall.java +++ b/solr/core/src/java/org/apache/solr/servlet/HttpSolrCall.java @@ -40,6 +40,7 @@ import java.lang.invoke.MethodHandles; import java.nio.charset.StandardCharsets; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.Enumeration; @@ -1089,22 +1090,15 @@ private SolrCore checkProps(ZkNodeProps zkProps) { return core; } - private void getSlicesForCollections( - ClusterState clusterState, Collection slices, boolean activeSlices) { + private List getSlicesForAllCollections(ClusterState clusterState, boolean activeSlices) { + // looks across *all* collections if (activeSlices) { - for (Map.Entry entry : clusterState.getCollectionsMap().entrySet()) { - final Slice[] activeCollectionSlices = entry.getValue().getActiveSlicesArr(); - if (activeCollectionSlices != null) { - Collections.addAll(slices, activeCollectionSlices); - } - } + return clusterState + .collectionStream() + .flatMap(coll -> Arrays.stream(coll.getActiveSlicesArr())) + .toList(); } else { - for (Map.Entry entry : clusterState.getCollectionsMap().entrySet()) { - final Collection collectionSlices = entry.getValue().getSlices(); - if (collectionSlices != null) { - slices.addAll(collectionSlices); - } - } + return clusterState.collectionStream().flatMap(coll -> coll.getSlices().stream()).toList(); } } @@ -1113,20 +1107,20 @@ protected String getRemoteCoreUrl(String collectionName, String origCorename) ClusterState clusterState = cores.getZkController().getClusterState(); final DocCollection docCollection = clusterState.getCollectionOrNull(collectionName); Slice[] slices = (docCollection != null) ? docCollection.getActiveSlicesArr() : null; - List activeSlices = new ArrayList<>(); + List activeSlices; boolean byCoreName = false; int totalReplicas = 0; if (slices == null) { byCoreName = true; - activeSlices = new ArrayList<>(); - getSlicesForCollections(clusterState, activeSlices, true); + // all collections! + activeSlices = getSlicesForAllCollections(clusterState, true); if (activeSlices.isEmpty()) { - getSlicesForCollections(clusterState, activeSlices, false); + activeSlices = getSlicesForAllCollections(clusterState, false); } } else { - Collections.addAll(activeSlices, slices); + activeSlices = List.of(slices); } for (Slice s : activeSlices) { @@ -1171,9 +1165,16 @@ private String getCoreUrl( boolean activeReplicas) { String coreUrl; Set liveNodes = clusterState.getLiveNodes(); - Collections.shuffle(slices, Utils.RANDOM); - for (Slice slice : slices) { + List shuffledSlices; + if (slices.size() < 2) { + shuffledSlices = slices; + } else { + shuffledSlices = new ArrayList<>(slices); + Collections.shuffle(shuffledSlices, Utils.RANDOM); + } + + for (Slice slice : shuffledSlices) { List randomizedReplicas = new ArrayList<>(slice.getReplicas()); Collections.shuffle(randomizedReplicas, Utils.RANDOM); diff --git a/solr/core/src/test/org/apache/solr/cloud/CollectionsAPISolrJTest.java b/solr/core/src/test/org/apache/solr/cloud/CollectionsAPISolrJTest.java index cba11e7d064..cf338640579 100644 --- a/solr/core/src/test/org/apache/solr/cloud/CollectionsAPISolrJTest.java +++ b/solr/core/src/test/org/apache/solr/cloud/CollectionsAPISolrJTest.java @@ -37,6 +37,7 @@ import java.util.Optional; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; +import java.util.stream.Collectors; import org.apache.lucene.tests.util.TestUtil; import org.apache.solr.client.solrj.SolrClient; import org.apache.solr.client.solrj.SolrRequest; @@ -1027,7 +1028,7 @@ public void testDeleteAliasedCollection() throws Exception { delete.setFollowAliases(false); delete.process(solrClient); ClusterState state = solrClient.getClusterState(); - assertFalse(state.getCollectionsMap().toString(), state.hasCollection(collectionName1)); + assertFalse(collectionNamesString(state), state.hasCollection(collectionName1)); // search should still work, returning results from collection 2 assertDoc(solrClient, collectionName1, "2"); // aliased assertDoc(solrClient, collectionName2, "2"); // direct @@ -1048,7 +1049,7 @@ public void testDeleteAliasedCollection() throws Exception { state = solrClient.getClusterState(); // the collection is gone - assertFalse(state.getCollectionsMap().toString(), state.hasCollection(collectionName2)); + assertFalse(collectionNamesString(state), state.hasCollection(collectionName2)); // and the alias is gone RetryUtil.retryUntil( @@ -1067,6 +1068,10 @@ public void testDeleteAliasedCollection() throws Exception { }); } + private static String collectionNamesString(ClusterState state) { + return state.collectionStream().map(Object::toString).collect(Collectors.joining(",")); + } + private void assertDoc(CloudSolrClient solrClient, String collection, String id) throws Exception { QueryResponse rsp = solrClient.query(collection, params(CommonParams.Q, "*:*")); diff --git a/solr/core/src/test/org/apache/solr/cloud/OverseerTest.java b/solr/core/src/test/org/apache/solr/cloud/OverseerTest.java index 8e7e45333f4..bad8d58d021 100644 --- a/solr/core/src/test/org/apache/solr/cloud/OverseerTest.java +++ b/solr/core/src/test/org/apache/solr/cloud/OverseerTest.java @@ -1412,16 +1412,14 @@ public void testDoubleAssignment() throws Exception { reader.forceUpdateCollection(COLLECTION); ClusterState state = reader.getClusterState(); - int numFound = 0; - Map collectionsMap = state.getCollectionsMap(); - for (Map.Entry entry : collectionsMap.entrySet()) { - DocCollection collection = entry.getValue(); - for (Slice slice : collection.getSlices()) { - if (slice.getReplicasMap().get("core_node1") != null) { - numFound++; - } - } - } + long numFound = + state + .collectionStream() + .map(DocCollection::getSlices) + .flatMap(Collection::stream) + .filter(slice -> slice.getReplicasMap().get("core_node1") != null) + .count(); + assertEquals("Shard was found more than once in ClusterState", 1, numFound); } finally { close(overseerClient); diff --git a/solr/modules/hdfs/src/test/org/apache/solr/hdfs/cloud/SharedFileSystemAutoReplicaFailoverTest.java b/solr/modules/hdfs/src/test/org/apache/solr/hdfs/cloud/SharedFileSystemAutoReplicaFailoverTest.java index 34e3b2a1492..68fd8715181 100644 --- a/solr/modules/hdfs/src/test/org/apache/solr/hdfs/cloud/SharedFileSystemAutoReplicaFailoverTest.java +++ b/solr/modules/hdfs/src/test/org/apache/solr/hdfs/cloud/SharedFileSystemAutoReplicaFailoverTest.java @@ -47,11 +47,8 @@ import org.apache.solr.client.solrj.response.QueryResponse; import org.apache.solr.cloud.AbstractFullDistribZkTestBase; import org.apache.solr.cloud.ChaosMonkey; -import org.apache.solr.common.SolrException; import org.apache.solr.common.SolrInputDocument; -import org.apache.solr.common.cloud.ClusterState; import org.apache.solr.common.cloud.ClusterStateUtil; -import org.apache.solr.common.cloud.DocCollection; import org.apache.solr.common.cloud.Replica; import org.apache.solr.common.cloud.Slice; import org.apache.solr.common.cloud.ZkStateReader; @@ -382,44 +379,17 @@ private boolean waitingForReplicasNotLive( .filter(jetty -> jetty.getCoreContainer() != null) .map(JettySolrRunner::getNodeName) .collect(Collectors.toSet()); - long timeout = - System.nanoTime() + TimeUnit.NANOSECONDS.convert(timeoutInMs, TimeUnit.MILLISECONDS); - boolean success = false; - while (!success && System.nanoTime() < timeout) { - success = true; - ClusterState clusterState = zkStateReader.getClusterState(); - if (clusterState != null) { - Map collections = clusterState.getCollectionsMap(); - for (Map.Entry entry : collections.entrySet()) { - DocCollection docCollection = entry.getValue(); - Collection slices = docCollection.getSlices(); - for (Slice slice : slices) { - // only look at active shards - if (slice.getState() == Slice.State.ACTIVE) { - Collection replicas = slice.getReplicas(); - for (Replica replica : replicas) { - if (nodeNames.contains(replica.getNodeName())) { - boolean live = clusterState.liveNodesContain(replica.getNodeName()); - if (live) { - success = false; - } - } - } - } - } - } - if (!success) { - try { - Thread.sleep(500); - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Interrupted"); - } - } - } - } - - return success; + return ClusterStateUtil.waitFor( + zkStateReader, + null, + timeoutInMs, + TimeUnit.MILLISECONDS, + (liveNodes, state) -> + ClusterStateUtil.replicasOfActiveSlicesStream(state) + .noneMatch( + replica -> + nodeNames.contains(replica.getNodeName()) + && liveNodes.contains(replica.getNodeName()))); } private void assertSliceAndReplicaCount( diff --git a/solr/prometheus-exporter/src/java/org/apache/solr/prometheus/scraper/SolrCloudScraper.java b/solr/prometheus-exporter/src/java/org/apache/solr/prometheus/scraper/SolrCloudScraper.java index e333076dbe2..79c3e46ae2c 100644 --- a/solr/prometheus-exporter/src/java/org/apache/solr/prometheus/scraper/SolrCloudScraper.java +++ b/solr/prometheus-exporter/src/java/org/apache/solr/prometheus/scraper/SolrCloudScraper.java @@ -57,10 +57,10 @@ public SolrCloudScraper( public Map pingAllCores(MetricsQuery query) throws IOException { Map httpSolrClients = createHttpSolrClients(); - Map collectionState = solrClient.getClusterState().getCollectionsMap(); - List replicas = - collectionState.values().stream() + solrClient + .getClusterState() + .collectionStream() .map(DocCollection::getReplicas) .flatMap(List::stream) .collect(Collectors.toList()); @@ -131,7 +131,9 @@ public MetricSamples collections(MetricsQuery metricsQuery) throws IOException { } private Set getBaseUrls() throws IOException { - return solrClient.getClusterState().getCollectionsMap().values().stream() + return solrClient + .getClusterState() + .collectionStream() .map(DocCollection::getReplicas) .flatMap(List::stream) .map(Replica::getBaseUrl) diff --git a/solr/prometheus-exporter/src/test/org/apache/solr/prometheus/scraper/SolrCloudScraperTest.java b/solr/prometheus-exporter/src/test/org/apache/solr/prometheus/scraper/SolrCloudScraperTest.java index 2ebc3752cae..386b1252e04 100644 --- a/solr/prometheus-exporter/src/test/org/apache/solr/prometheus/scraper/SolrCloudScraperTest.java +++ b/solr/prometheus-exporter/src/test/org/apache/solr/prometheus/scraper/SolrCloudScraperTest.java @@ -115,17 +115,15 @@ public void pingCores() throws Exception { Map allCoreMetrics = solrCloudScraper.pingAllCores(configuration.getPingConfiguration().get(0)); - Map collectionStates = getClusterState().getCollectionsMap(); + final List collectionStates = getClusterState().collectionStream().toList(); long coreCount = - collectionStates.entrySet().stream() - .mapToInt(entry -> entry.getValue().getReplicas().size()) - .sum(); + collectionStates.stream().mapToInt(docColl -> docColl.getReplicas().size()).sum(); assertEquals(coreCount, allCoreMetrics.size()); - for (Map.Entry entry : collectionStates.entrySet()) { - String coreName = entry.getValue().getReplicas().get(0).getCoreName(); + for (DocCollection docColl : collectionStates) { + String coreName = docColl.getReplicas().get(0).getCoreName(); assertTrue(allCoreMetrics.containsKey(coreName)); List coreMetrics = allCoreMetrics.get(coreName).asList(); assertEquals(1, coreMetrics.size()); diff --git a/solr/solrj/src/java/org/apache/solr/common/cloud/ClusterState.java b/solr/solrj/src/java/org/apache/solr/common/cloud/ClusterState.java index 6219625dbd5..f4945921821 100644 --- a/solr/solrj/src/java/org/apache/solr/common/cloud/ClusterState.java +++ b/solr/solrj/src/java/org/apache/solr/common/cloud/ClusterState.java @@ -173,7 +173,9 @@ public Collection getCollectionNames() { * semantics of how collection list is loaded have changed in SOLR-6629. * * @return a map of collection name vs DocCollection object + * @deprecated see {@link #collectionStream()} */ + @Deprecated public Map getCollectionsMap() { Map result = CollectionUtil.newHashMap(collectionStates.size()); for (Entry entry : collectionStates.entrySet()) { @@ -415,8 +417,8 @@ public Set getHostAllowList() { } /** - * Streams the resolved {@link DocCollection}s. Use this sparingly in case there are many - * collections. + * Streams the resolved {@link DocCollection}s, which will often fetch from ZooKeeper for each one + * for a many-collection scenario. Use this sparingly; some users have thousands of collections! */ public Stream collectionStream() { return collectionStates.values().stream().map(CollectionRef::get).filter(Objects::nonNull); diff --git a/solr/test-framework/src/java/org/apache/solr/cloud/AbstractFullDistribZkTestBase.java b/solr/test-framework/src/java/org/apache/solr/cloud/AbstractFullDistribZkTestBase.java index 003ef951b0f..0a88523f13a 100644 --- a/solr/test-framework/src/java/org/apache/solr/cloud/AbstractFullDistribZkTestBase.java +++ b/solr/test-framework/src/java/org/apache/solr/cloud/AbstractFullDistribZkTestBase.java @@ -69,6 +69,7 @@ import org.apache.solr.common.SolrException.ErrorCode; import org.apache.solr.common.SolrInputDocument; import org.apache.solr.common.cloud.ClusterState; +import org.apache.solr.common.cloud.ClusterStateUtil; import org.apache.solr.common.cloud.DocCollection; import org.apache.solr.common.cloud.Replica; import org.apache.solr.common.cloud.Slice; @@ -105,8 +106,6 @@ import org.junit.AfterClass; import org.junit.Before; import org.junit.BeforeClass; -import org.noggit.CharArr; -import org.noggit.JSONWriter; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -2539,10 +2538,7 @@ protected String printClusterStateInfo(String collection) throws Exception { if (collection != null) { cs = clusterState.getCollection(collection).toString(); } else { - Map map = clusterState.getCollectionsMap(); - CharArr out = new CharArr(); - new JSONWriter(out, 2).write(map); - cs = out.toString(); + cs = ClusterStateUtil.toDebugAllStatesString(clusterState); } return cs; } diff --git a/solr/test-framework/src/java/org/apache/solr/common/cloud/ClusterStateUtil.java b/solr/test-framework/src/java/org/apache/solr/common/cloud/ClusterStateUtil.java index 9442f9e1d25..9ecfe57379d 100644 --- a/solr/test-framework/src/java/org/apache/solr/common/cloud/ClusterStateUtil.java +++ b/solr/test-framework/src/java/org/apache/solr/common/cloud/ClusterStateUtil.java @@ -16,18 +16,18 @@ */ package org.apache.solr.common.cloud; -import java.lang.invoke.MethodHandles; import java.util.Collection; -import java.util.Collections; +import java.util.LinkedHashMap; import java.util.Map; +import java.util.Set; import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.stream.Stream; import org.apache.solr.common.SolrException; import org.apache.solr.common.SolrException.ErrorCode; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import org.apache.solr.common.util.Utils; public class ClusterStateUtil { - private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass()); private static final int TIMEOUT_POLL_MS = 1000; @@ -53,109 +53,21 @@ public static boolean waitForAllActiveAndLiveReplicas( */ public static boolean waitForAllActiveAndLiveReplicas( ZkStateReader zkStateReader, String collection, int timeoutInMs) { - long timeout = - System.nanoTime() + TimeUnit.NANOSECONDS.convert(timeoutInMs, TimeUnit.MILLISECONDS); - boolean success = false; - while (!success && System.nanoTime() < timeout) { - success = true; - ClusterState clusterState = zkStateReader.getClusterState(); - if (clusterState != null) { - Map collections = null; - if (collection != null) { - collections = - Collections.singletonMap(collection, clusterState.getCollection(collection)); - } else { - collections = clusterState.getCollectionsMap(); - } - for (Map.Entry entry : collections.entrySet()) { - DocCollection docCollection = entry.getValue(); - Collection slices = docCollection.getSlices(); - for (Slice slice : slices) { - // only look at active shards - if (slice.getState() == Slice.State.ACTIVE) { - Collection replicas = slice.getReplicas(); - for (Replica replica : replicas) { - // on a live node? - final boolean live = clusterState.liveNodesContain(replica.getNodeName()); - final boolean isActive = replica.getState() == Replica.State.ACTIVE; - if (!live || !isActive) { - // fail - success = false; - } - } - } - } - } - if (!success) { - try { - Thread.sleep(TIMEOUT_POLL_MS); - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - throw new SolrException(ErrorCode.SERVER_ERROR, "Interrupted"); - } - } - } - } - - return success; + return waitFor( + zkStateReader, + collection, + timeoutInMs, + TimeUnit.MILLISECONDS, + (liveNodes, state) -> + replicasOfActiveSlicesStream(state) + .allMatch(replica -> liveAndActivePredicate(replica, liveNodes))); } - /** - * Wait to see an entry in the ClusterState with a specific coreNodeName and baseUrl. - * - * @param zkStateReader to use for ClusterState - * @param collection to look in - * @param coreNodeName to wait for - * @param baseUrl to wait for - * @param timeoutInMs how long to wait before giving up - * @return false if timed out - */ - public static boolean waitToSeeLiveReplica( - ZkStateReader zkStateReader, - String collection, - String coreNodeName, - String baseUrl, - int timeoutInMs) { - long timeout = - System.nanoTime() + TimeUnit.NANOSECONDS.convert(timeoutInMs, TimeUnit.MILLISECONDS); - - while (System.nanoTime() < timeout) { - log.debug( - "waiting to see replica just created live collection={} replica={} baseUrl={}", - collection, - coreNodeName, - baseUrl); - ClusterState clusterState = zkStateReader.getClusterState(); - if (clusterState != null) { - DocCollection docCollection = clusterState.getCollection(collection); - Collection slices = docCollection.getSlices(); - for (Slice slice : slices) { - // only look at active shards - if (slice.getState() == Slice.State.ACTIVE) { - Collection replicas = slice.getReplicas(); - for (Replica replica : replicas) { - // on a live node? - boolean live = clusterState.liveNodesContain(replica.getNodeName()); - String rcoreNodeName = replica.getName(); - String rbaseUrl = replica.getBaseUrl(); - if (live && coreNodeName.equals(rcoreNodeName) && baseUrl.equals(rbaseUrl)) { - // found it - return true; - } - } - } - } - try { - Thread.sleep(TIMEOUT_POLL_MS); - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - throw new SolrException(ErrorCode.SERVER_ERROR, "Interrupted"); - } - } - } - - log.error("Timed out waiting to see replica just created in cluster state. Continuing..."); - return false; + private static boolean liveAndActivePredicate(Replica replica, Set liveNodes) { + // on a live node? + final boolean live = liveNodes.contains(replica.getNodeName()); + final boolean isActive = replica.getState() == Replica.State.ACTIVE; + return live && isActive; } public static boolean waitForAllReplicasNotLive(ZkStateReader zkStateReader, int timeoutInMs) { @@ -164,86 +76,111 @@ public static boolean waitForAllReplicasNotLive(ZkStateReader zkStateReader, int public static boolean waitForAllReplicasNotLive( ZkStateReader zkStateReader, String collection, int timeoutInMs) { - long timeout = - System.nanoTime() + TimeUnit.NANOSECONDS.convert(timeoutInMs, TimeUnit.MILLISECONDS); - boolean success = false; - while (!success && System.nanoTime() < timeout) { - success = true; - ClusterState clusterState = zkStateReader.getClusterState(); - if (clusterState != null) { - Map collections = null; - if (collection != null) { - collections = - Collections.singletonMap(collection, clusterState.getCollection(collection)); - } else { - collections = clusterState.getCollectionsMap(); - } - for (Map.Entry entry : collections.entrySet()) { - DocCollection docCollection = entry.getValue(); - Collection slices = docCollection.getSlices(); - for (Slice slice : slices) { - // only look at active shards - if (slice.getState() == Slice.State.ACTIVE) { - Collection replicas = slice.getReplicas(); - for (Replica replica : replicas) { - // on a live node? - boolean live = clusterState.liveNodesContain(replica.getNodeName()); - if (live) { - // fail - success = false; - } - } - } - } - } - if (!success) { - try { - Thread.sleep(TIMEOUT_POLL_MS); - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - throw new SolrException(ErrorCode.SERVER_ERROR, "Interrupted"); - } - } - } - } - - return success; + return waitFor( + zkStateReader, + collection, + timeoutInMs, + TimeUnit.MILLISECONDS, + (liveNodes, state) -> + replicasOfActiveSlicesStream(state) + .noneMatch(replica -> liveNodes.contains(replica.getNodeName()))); } public static int getLiveAndActiveReplicaCount(ZkStateReader zkStateReader, String collection) { - Slice[] slices; - slices = zkStateReader.getClusterState().getCollection(collection).getActiveSlicesArr(); - int liveAndActive = 0; - for (Slice slice : slices) { - for (Replica replica : slice.getReplicas()) { - boolean live = zkStateReader.getClusterState().liveNodesContain(replica.getNodeName()); - boolean active = replica.getState() == Replica.State.ACTIVE; - if (live && active) { - liveAndActive++; - } - } - } - return liveAndActive; + ClusterState clusterState = zkStateReader.getClusterState(); + var liveNodes = clusterState.getLiveNodes(); + var state = clusterState.getCollection(collection); + return (int) + replicasOfActiveSlicesStream(state) + .filter(replica -> liveAndActivePredicate(replica, liveNodes)) + .count(); + } + + public static Stream replicasOfActiveSlicesStream(DocCollection collectionState) { + return collectionState.getActiveSlices().stream() + .map(Slice::getReplicas) + .flatMap(Collection::stream); } public static boolean waitForLiveAndActiveReplicaCount( ZkStateReader zkStateReader, String collection, int replicaCount, int timeoutInMs) { - long timeout = - System.nanoTime() + TimeUnit.NANOSECONDS.convert(timeoutInMs, TimeUnit.MILLISECONDS); - boolean success = false; - while (!success && System.nanoTime() < timeout) { - success = getLiveAndActiveReplicaCount(zkStateReader, collection) == replicaCount; - - if (!success) { - try { - Thread.sleep(TIMEOUT_POLL_MS); - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - throw new SolrException(ErrorCode.SERVER_ERROR, "Interrupted"); + return waitFor( + zkStateReader, + collection, + timeoutInMs, + TimeUnit.MILLISECONDS, + (liveNodes, state) -> + replicasOfActiveSlicesStream(state) + .filter(replica -> liveAndActivePredicate(replica, liveNodes)) + .count() + == replicaCount); + } + + /** + * Calls {@link ZkStateReader#waitForState(String, long, TimeUnit, CollectionStatePredicate)} but + * has an alternative implementation if {@code collection} is null, in which the predicate must + * match *all* collections. Returns whether the predicate matches or not in the allotted time; + * does *NOT* throw {@link TimeoutException}. + */ + public static boolean waitFor( + ZkStateReader zkStateReader, + String collection, + long timeout, + TimeUnit timeUnit, + CollectionStatePredicate predicate) { + // ideally a collection is specified... + if (collection != null) { + try { + zkStateReader.waitForState(collection, timeout, timeUnit, predicate); + return true; + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + throw new SolrException(ErrorCode.SERVER_ERROR, "Interrupted"); + } catch (TimeoutException e) { + return false; + } + } + + // otherwise we check all collections... + + final long timeoutAtNs = System.nanoTime() + TimeUnit.NANOSECONDS.convert(timeout, timeUnit); + while (true) { + ClusterState clusterState = zkStateReader.getClusterState(); // fresh state + if (clusterState != null) { // it's sad to deal with this; API contract should forbid + var liveNodes = clusterState.getLiveNodes(); + if (clusterState + .collectionStream() + .allMatch(state -> predicate.matches(liveNodes, state))) { + return true; } } + + if (System.nanoTime() > timeoutAtNs) { + return false; + } + + try { + Thread.sleep(TIMEOUT_POLL_MS); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + throw new SolrException(ErrorCode.SERVER_ERROR, "Interrupted"); + } } + } - return success; + /** Produces a String of all the collection states for debugging. ZK may be consulted. */ + public static String toDebugAllStatesString(ClusterState clusterState) { + // note: ClusterState.toString prints the in-memory state info it has without consulting ZK + + // Collect to a Map by name, loading each DocCollection expressed as a Map + var stateMap = + clusterState + .collectionStream() + .collect( + LinkedHashMap::new, + (map, state) -> map.put(state.getName(), state.toMap(new LinkedHashMap<>())), + Map::putAll); + // toJSON requires standard types like Map; doesn't know about DocCollection etc. + return Utils.toJSONString(stateMap); } } From c9d3885f2fd0a7edf5efe4a264d0bdc276109eba Mon Sep 17 00:00:00 2001 From: Christos Malliaridis Date: Fri, 15 Nov 2024 20:24:48 +0200 Subject: [PATCH 05/33] SOLR-17406: Introduce Version Catalogs (#2706) Introduce project-wide Gradle versions catalogs. Read the updated docs for more information. Breaking Changes: Any dependencies added from now on are no longer added to versions.props (file removed), but to gradle/libs.versions.toml. When referencing a dependency in a gradle module, use the version catalog instead of hardcoded strings. Dependencies are now locked with gradlew writeLocks (subject to change). --- build-tools/build-infra/build.gradle | 11 +- build-tools/build-infra/settings.gradle | 9 + build-tools/missing-doclet/build.gradle | 10 +- build-tools/missing-doclet/settings.gradle | 9 + build-tools/scriptDepVersions.gradle | 33 - build.gradle | 31 +- dev-docs/dependency-upgrades.adoc | 43 +- gradle/documentation/markdown.gradle | 8 +- .../documentation/pull-lucene-javadocs.gradle | 10 +- gradle/generation/javacc.gradle | 2 +- gradle/ide/eclipse.gradle | 89 +- gradle/libs.versions.toml | 460 + .../lucene-dev-repo-composite.gradle | 2 +- gradle/maven/defaults-maven.gradle | 11 - gradle/node.gradle | 4 +- gradle/testing/randomization.gradle | 2 +- gradle/validation/check-environment.gradle | 4 +- gradle/validation/dependencies.gradle | 349 + gradle/validation/dependency-analyze.gradle | 2 +- gradle/validation/ecj-lint.gradle | 2 +- gradle/validation/error-prone.gradle | 17 +- gradle/validation/forbidden-apis.gradle | 2 +- gradle/validation/git-status.gradle | 2 +- gradle/validation/jar-checks.gradle | 2 +- gradle/validation/precommit.gradle | 2 - gradle/validation/rat-sources.gradle | 2 +- gradle/validation/spotless.gradle | 4 +- .../validate-source-patterns.gradle | 2 +- .../validation/versions-props-sorted.gradle | 35 - help/dependencies.txt | 170 +- settings-gradle.lockfile | 4 + solr/api/build.gradle | 18 +- solr/benchmark/build.gradle | 35 +- solr/core/build.gradle | 186 +- solr/cross-dc-manager/build.gradle | 60 +- solr/docker/build.gradle | 4 +- solr/licenses/hamcrest-core-3.0.jar.sha1 | 1 - solr/modules/analysis-extras/build.gradle | 28 +- solr/modules/clustering/build.gradle | 14 +- solr/modules/cross-dc/build.gradle | 30 +- solr/modules/extraction/build.gradle | 18 +- solr/modules/gcs-repository/build.gradle | 31 +- solr/modules/hadoop-auth/build.gradle | 74 +- solr/modules/hdfs/build.gradle | 49 +- solr/modules/jwt-auth/build.gradle | 46 +- solr/modules/langid/build.gradle | 15 +- solr/modules/ltr/build.gradle | 18 +- solr/modules/opentelemetry/build.gradle | 31 +- solr/modules/s3-repository/build.gradle | 52 +- solr/modules/scripting/build.gradle | 12 +- solr/modules/sql/build.gradle | 18 +- solr/packaging/build.gradle | 6 +- solr/prometheus-exporter/build.gradle | 36 +- solr/server/build.gradle | 68 +- solr/solr-ref-guide/build.gradle | 71 +- solr/solrj-streaming/build.gradle | 20 +- solr/solrj-zookeeper/build.gradle | 18 +- solr/solrj/build.gradle | 79 +- solr/test-framework/build.gradle | 74 +- solr/webapp/build.gradle | 7 +- versions.lock | 20656 +++++++++++++++- versions.props | 76 - 62 files changed, 21820 insertions(+), 1364 deletions(-) delete mode 100644 build-tools/scriptDepVersions.gradle create mode 100644 gradle/libs.versions.toml create mode 100644 gradle/validation/dependencies.gradle delete mode 100644 gradle/validation/versions-props-sorted.gradle create mode 100644 settings-gradle.lockfile delete mode 100644 solr/licenses/hamcrest-core-3.0.jar.sha1 delete mode 100644 versions.props diff --git a/build-tools/build-infra/build.gradle b/build-tools/build-infra/build.gradle index 0d78cce49bf..9b5ff387488 100644 --- a/build-tools/build-infra/build.gradle +++ b/build-tools/build-infra/build.gradle @@ -17,7 +17,7 @@ plugins { id "java-gradle-plugin" - id 'com.diffplug.spotless' version '6.5.2' apply false + alias(libs.plugins.diffplug.spotless) apply false } repositories { @@ -34,12 +34,9 @@ apply from: file('../../gradle/validation/check-environment.gradle') tasks.register("checkJdkInternalsExportedToGradle") {} apply from: file('../../gradle/validation/spotless.gradle') -// Load common script dependencies. -apply from: file("../scriptDepVersions.gradle") - java { - sourceCompatibility = scriptDepVersions['min-java-version'] - targetCompatibility = scriptDepVersions['min-java-version'] + sourceCompatibility = JavaVersion.toVersion(libs.versions.java.min.get()) + targetCompatibility = JavaVersion.toVersion(libs.versions.java.min.get()) } gradlePlugin { @@ -57,5 +54,5 @@ dependencies { implementation gradleApi() implementation localGroovy() - implementation "commons-codec:commons-codec:${scriptDepVersions['commons-codec']}" + implementation libs.commonscodec.commonscodec } diff --git a/build-tools/build-infra/settings.gradle b/build-tools/build-infra/settings.gradle index 350b781b7f4..7a55021b366 100644 --- a/build-tools/build-infra/settings.gradle +++ b/build-tools/build-infra/settings.gradle @@ -16,3 +16,12 @@ */ rootProject.name = 'build-infra' + +// Use project's version catalog for centralized dependency management +dependencyResolutionManagement { + versionCatalogs { + libs { + from(files("../../gradle/libs.versions.toml")) + } + } +} diff --git a/build-tools/missing-doclet/build.gradle b/build-tools/missing-doclet/build.gradle index 2525f50d79b..11a7fc6e2a8 100644 --- a/build-tools/missing-doclet/build.gradle +++ b/build-tools/missing-doclet/build.gradle @@ -17,14 +17,13 @@ plugins { id 'java-library' - id 'com.diffplug.spotless' version '6.5.2' apply false + alias(libs.plugins.diffplug.spotless) apply false } repositories { mavenCentral() } -version = "1.0.0-SNAPSHOT" group = "org.apache.solr.tools" description = 'Doclet-based javadoc validation' @@ -36,12 +35,9 @@ apply from: file('../../gradle/validation/check-environment.gradle') tasks.register("checkJdkInternalsExportedToGradle") {} apply from: file('../../gradle/validation/spotless.gradle') -// Load common script dependencies. -apply from: file("../scriptDepVersions.gradle") - java { - sourceCompatibility = scriptDepVersions['min-java-version'] - targetCompatibility = scriptDepVersions['min-java-version'] + sourceCompatibility = JavaVersion.toVersion(libs.versions.java.min.get()) + targetCompatibility = JavaVersion.toVersion(libs.versions.java.min.get()) } tasks.withType(JavaCompile).configureEach { diff --git a/build-tools/missing-doclet/settings.gradle b/build-tools/missing-doclet/settings.gradle index 73d696331bc..c39219472be 100644 --- a/build-tools/missing-doclet/settings.gradle +++ b/build-tools/missing-doclet/settings.gradle @@ -16,3 +16,12 @@ */ rootProject.name = "missing-doclet" + +// Use project's version catalog for centralized dependency management +dependencyResolutionManagement { + versionCatalogs { + libs { + from(files("../../gradle/libs.versions.toml")) + } + } +} diff --git a/build-tools/scriptDepVersions.gradle b/build-tools/scriptDepVersions.gradle deleted file mode 100644 index 329905331a9..00000000000 --- a/build-tools/scriptDepVersions.gradle +++ /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. - */ - -// Declare script dependency versions outside of palantir's -// version unification control. These are not our main dependencies -// but are reused in buildSrc and across applied scripts. - -ext { - scriptDepVersions = [ - "min-java-version": "21", - "min-solrj-java-version" : "17", - "apache-rat": "0.15", - "commons-codec": "1.16.0", - "ecj": "3.39.0", - "javacc": "7.0.12", - "jgit": "6.7.0.202309050840-r", - "flexmark": "0.64.8", - ] -} diff --git a/build.gradle b/build.gradle index 13065fcfc8f..9e40cfbcf88 100644 --- a/build.gradle +++ b/build.gradle @@ -21,21 +21,23 @@ import java.time.format.DateTimeFormatter plugins { id 'base' id 'solr.build-infra' - id 'com.palantir.consistent-versions' version '2.16.0' - id 'org.owasp.dependencycheck' version '9.0.8' - id 'ca.cutterslade.analyze' version '1.10.0' - id 'de.thetaphi.forbiddenapis' version '3.7' apply false - id 'de.undercouch.download' version '5.5.0' apply false - id 'net.ltgt.errorprone' version '3.1.0' apply false - id 'com.diffplug.spotless' version '6.5.2' apply false - id 'com.github.node-gradle.node' version '7.0.1' apply false -} -apply from: file('build-tools/scriptDepVersions.gradle') + alias(libs.plugins.carrotsearch.dependencychecks) + alias(libs.plugins.owasp.dependencycheck) + alias(libs.plugins.cutterslade.analyze) + alias(libs.plugins.benmanes.versions) + alias(libs.plugins.littlerobots.versioncatalogupdate) apply false + alias(libs.plugins.thetaphi.forbiddenapis) apply false + alias(libs.plugins.undercouch.download) apply false + alias(libs.plugins.ltgt.errorprone) apply false + alias(libs.plugins.diffplug.spotless) apply false + alias(libs.plugins.nodegradle.node) apply false + alias(libs.plugins.openapi.generator) apply false +} // Declare default Java versions for the entire project and for SolrJ separately -rootProject.ext.minJavaVersionDefault = JavaVersion.toVersion(scriptDepVersions['min-java-version']) -rootProject.ext.minJavaVersionSolrJ = JavaVersion.toVersion(scriptDepVersions['min-solrj-java-version']) +rootProject.ext.minJavaVersionDefault = JavaVersion.toVersion(libs.versions.java.min.get()) +rootProject.ext.minJavaVersionSolrJ = JavaVersion.toVersion(libs.versions.java.solrj.get()) apply from: file('gradle/globals.gradle') @@ -100,7 +102,7 @@ ext { } luceneBaseVersionProvider = project.provider { - def luceneVersion = getVersion('org.apache.lucene:lucene-core') + def luceneVersion = libs.versions.apache.lucene.get() def m = (luceneVersion =~ /^\d+\.\d+\.\d+\b/) if (!m) { throw GradleException("Can't strip base version from " + luceneVersion) @@ -150,7 +152,6 @@ apply from: file('gradle/validation/precommit.gradle') apply from: file('gradle/validation/forbidden-apis.gradle') apply from: file('gradle/validation/jar-checks.gradle') apply from: file('gradle/validation/git-status.gradle') -apply from: file('gradle/validation/versions-props-sorted.gradle') apply from: file('gradle/validation/validate-source-patterns.gradle') apply from: file('gradle/validation/rat-sources.gradle') apply from: file('gradle/validation/owasp-dependency-check.gradle') @@ -161,7 +162,7 @@ apply from: file('gradle/validation/validate-log-calls.gradle') apply from: file('gradle/validation/check-broken-links.gradle') apply from: file('gradle/validation/solr.config-file-sanity.gradle') - +apply from: file('gradle/validation/dependencies.gradle') apply from: file('gradle/validation/spotless.gradle') // Wire up included builds to some validation tasks. diff --git a/dev-docs/dependency-upgrades.adoc b/dev-docs/dependency-upgrades.adoc index 9f7372cc1bd..aa5cd93a2de 100644 --- a/dev-docs/dependency-upgrades.adoc +++ b/dev-docs/dependency-upgrades.adoc @@ -16,30 +16,57 @@ // specific language governing permissions and limitations // under the License. -Solr has lots of 3rd party dependencies, defined mainly in `versions.props`. +Solr has lots of 3rd party dependencies, defined in `gradle/libs.versions.toml`. Keeping them up-to-date is crucial for a number of reasons: * minimizing the risk of critical CVE vulnerabilities by staying on a recent and supported version * avoiding "dependency hell", that can arise from falling too far behind -Read the https://github.com/apache/solr/blob/main/help/dependencies.txt[help/dependencies.txt] file for an in-depth explanation of how gradle is deployed in Solr, using -https://github.com/palantir/gradle-consistent-versions[Gradle consistent-versions] plugin. +Read the https://github.com/apache/solr/blob/main/help/dependencies.txt[help/dependencies.txt] file for an in-depth +explanation of how dependencies are managed. == Manual dependency upgrades In order to upgrade a dependency, you need to run through a number of steps: 1. Identify the available versions from e.g. https://search.maven.org[Maven Central] -2. Update the version in `versions.props` file -3. Run `./gradlew --write-locks` to re-generate `versions.lock`. Note that this may cause a cascading effect where +2. Update the version in `gradle/libs.versions.toml` file +3. Run `./gradlew writeLocks` to re-generate `versions.lock`. Note that this may cause a cascading effect where the locked version of other dependencies also change. -4. Run `./gradlew updateLicenses` to re-generate SHA1 checksums of the new jar files. -5. Once in a while, a new version of a dependency will transitively bring in brand-new dependencies. +4. In case of a conflict, resolve the conflict according to `help/dependencies.txt` +5. Check if there are any constraints that are obsolete after the dependency update +6. Update the license and notice files of the changed dependencies. See `help/dependencies.txt` for + details. +7. Run `./gradlew updateLicenses` to re-generate SHA1 checksums of the new jar files. +8. Once in a while, a new version of a dependency will transitively bring in brand-new dependencies. You'll need to decide whether to keep or exclude them. See `help/dependencies.txt` for details. +=== Reviewing Constraints + +The constraints are defined in gradle/validation/dependencies.gradle. There, if the updated dependency is listed, +the constraint can be reviewed, updated or removed. + +The constraints fall into two "groups". In the first group there are dependency constraints from dependencies +that our project directly includes and require version alignment to sync the versions across all transitive +dependencies. In the second group are dependencies that are only present as transitive dependencies. +There, we try to follow the convention to provide additional information with "which dependencies use what version", +so that the next person reviewing the constraint does not have to look it up. However, this is quite time-consuming +to analyze the dependencies and therefore subject to change. + +In order to review a constraint, you have to check if the updated dependency is mentioned in any of the constraints, +either as a reason for another dependency constraint or as the constraint's dependency. Removing temporarily +a constraint, the task writeLocks will fail if the constraint is still required. + +This process and the constraints of dependencies.gradle are not optimal, as it is quite time-consuming and not obvious +by just looking at it. We just haven't found yet a more efficient way to maintain these constraints. + == Renovate bot Pull Requests + +The renovate bot may be replaced in the future with dependabot and this section may only be relevant for older +versions (<10.0). See https://lists.apache.org/thread/1sb9ttv3lp57z2yod1htx1fykp5sj73z for updates. + A member of the Solr community operates a Github bot running https://github.com/renovatebot/renovate[Renovate], which files Pull Requests to Solr with dependency upgrade proposals. The PRs are labeled `dependencies` and do include -changes resulting from `gradle --write-locks` and `updateLicenses`. +changes resulting from `./gradlew writeLocks` and `updateLicenses`. Community members and committers can then review, and if manual changes are needed, help bring the PR to completion. For many dependencies, a changelog is included in the PR text, which may help guide the upgrade decision. diff --git a/gradle/documentation/markdown.gradle b/gradle/documentation/markdown.gradle index 29d23d87c75..d9a890d72eb 100644 --- a/gradle/documentation/markdown.gradle +++ b/gradle/documentation/markdown.gradle @@ -33,10 +33,10 @@ buildscript { } dependencies { - classpath "com.vladsch.flexmark:flexmark:${scriptDepVersions['flexmark']}" - classpath "com.vladsch.flexmark:flexmark-ext-abbreviation:${scriptDepVersions['flexmark']}" - classpath "com.vladsch.flexmark:flexmark-ext-attributes:${scriptDepVersions['flexmark']}" - classpath "com.vladsch.flexmark:flexmark-ext-autolink:${scriptDepVersions['flexmark']}" + classpath libs.flexmark.flexmark + classpath libs.flexmark.extensions.abbreviation + classpath libs.flexmark.extensions.attributes + classpath libs.flexmark.extensions.autolink } } diff --git a/gradle/documentation/pull-lucene-javadocs.gradle b/gradle/documentation/pull-lucene-javadocs.gradle index 5fdc4a70040..17985d88f1b 100644 --- a/gradle/documentation/pull-lucene-javadocs.gradle +++ b/gradle/documentation/pull-lucene-javadocs.gradle @@ -45,11 +45,11 @@ configure(project(":solr:documentation")) { // from all Solr javadocs?) then perhaps we can find a way to build this list programatically? // - If these javadocs are (only every) consumed by the ref guide only, then these deps & associated tasks // should just be moved to the ref-guide build.gradle - javadocs group: 'org.apache.lucene', name: 'lucene-core', classifier: 'javadoc' - javadocs group: 'org.apache.lucene', name: 'lucene-analysis-common', classifier: 'javadoc' - javadocs group: 'org.apache.lucene', name: 'lucene-analysis-stempel', classifier: 'javadoc' - javadocs group: 'org.apache.lucene', name: 'lucene-queryparser', classifier: 'javadoc' - javadocs group: 'org.apache.lucene', name: 'lucene-spatial-extras', classifier: 'javadoc' + javadocs variantOf(libs.apache.lucene.core) { classifier 'javadoc' } + javadocs variantOf(libs.apache.lucene.analysis.common) { classifier 'javadoc' } + javadocs variantOf(libs.apache.lucene.analysis.stempel) { classifier 'javadoc' } + javadocs variantOf(libs.apache.lucene.queryparser) { classifier 'javadoc' } + javadocs variantOf(libs.apache.lucene.spatialextras) { classifier 'javadoc' } } diff --git a/gradle/generation/javacc.gradle b/gradle/generation/javacc.gradle index 54fc7e91359..0b70ba656ee 100644 --- a/gradle/generation/javacc.gradle +++ b/gradle/generation/javacc.gradle @@ -26,7 +26,7 @@ configure(rootProject) { } dependencies { - javacc "net.java.dev.javacc:javacc:${scriptDepVersions['javacc']}" + javacc libs.javacc.javacc } task javacc() { diff --git a/gradle/ide/eclipse.gradle b/gradle/ide/eclipse.gradle index a088c8b87a5..d7d453c39d9 100644 --- a/gradle/ide/eclipse.gradle +++ b/gradle/ide/eclipse.gradle @@ -21,65 +21,68 @@ import org.gradle.plugins.ide.eclipse.model.ClasspathEntry def resources = scriptResources(buildscript) configure(rootProject) { - apply plugin: "eclipse" + plugins.withType(JavaPlugin) { + apply plugin: "eclipse" - def relativize = { other -> rootProject.rootDir.relativePath(other).toString() } + def eclipseJavaVersion = propertyOrDefault("eclipse.javaVersion", libs.versions.java.min.get()) + def relativize = { other -> rootProject.rootDir.relativePath(other).toString() } - eclipse { - project { - name = "Apache Solr ${version}" - } + eclipse { + project { + name = "Apache Solr ${version}" + } - classpath { - downloadSources = true - downloadJavadoc = true - defaultOutputDir = file('build/eclipse') + classpath { + downloadSources = true + downloadJavadoc = true + defaultOutputDir = file('build/eclipse') - file { - beforeMerged { classpath -> classpath.entries.removeAll { it.kind == "src" } } + file { + beforeMerged { classpath -> classpath.entries.removeAll { it.kind == "src" } } - whenMerged { classpath -> - def projects = allprojects.findAll { prj -> - return prj.plugins.hasPlugin(JavaPlugin) && - prj.path != ":solr:solr-ref-guide" - } - - Set sources = [] - Set jars = [] - projects.each { prj -> - prj.sourceSets.each { sourceSet -> - sources += sourceSet.java.srcDirs.findAll { dir -> dir.exists() }.collect { dir -> relativize(dir) } - sources += sourceSet.resources.srcDirs.findAll { dir -> dir.exists() }.collect { dir -> relativize(dir) } + whenMerged { classpath -> + def projects = allprojects.findAll { prj -> + return prj.plugins.hasPlugin(JavaPlugin) && + prj.path != ":solr:solr-ref-guide" } - // This is hacky - we take the resolved compile classpath and just - // include JAR files from there. We should probably make it smarter - // by looking at real dependencies. But then: this Eclipse configuration - // doesn't really separate sources anyway so why bother. - jars += prj.configurations.compileClasspath.resolve() - jars += prj.configurations.testCompileClasspath.resolve() - } + Set sources = [] + Set jars = [] + projects.each { prj -> + prj.sourceSets.each { sourceSet -> + sources += sourceSet.java.srcDirs.findAll { dir -> dir.exists() }.collect { dir -> relativize(dir) } + sources += sourceSet.resources.srcDirs.findAll { dir -> dir.exists() }.collect { dir -> relativize(dir) } + } + + // This is hacky - we take the resolved compile classpath and just + // include JAR files from there. We should probably make it smarter + // by looking at real dependencies. But then: this Eclipse configuration + // doesn't really separate sources anyway so why bother. + jars += prj.configurations.compileClasspath.resolve() + jars += prj.configurations.testCompileClasspath.resolve() + } - classpath.entries += sources.sort().collect {name -> new SourceFolder(name, "build/eclipse/" + name) } - classpath.entries += jars.unique().findAll { location -> location.isFile() }.collect { location -> - new LibEntry(location.toString()) + classpath.entries += sources.sort().collect {name -> new SourceFolder(name, "build/eclipse/" + name) } + classpath.entries += jars.unique().findAll { location -> location.isFile() }.collect { location -> + new LibEntry(location.toString()) + } } } } } jdt { - sourceCompatibility = rootProject.minJavaVersionDefault - targetCompatibility = rootProject.minJavaVersionDefault - javaRuntimeName = "JavaSE-${rootProject.minJavaVersionDefault}" + sourceCompatibility = eclipseJavaVersion + targetCompatibility = eclipseJavaVersion + javaRuntimeName = "JavaSE-${eclipseJavaVersion}" } - } - eclipseJdt { - doLast { - project.sync { - from rootProject.file("${resources}/dot.settings") - into rootProject.file(".settings") + eclipseJdt { + doLast { + project.sync { + from rootProject.file("${resources}/dot.settings") + into rootProject.file(".settings") + } } } } diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml new file mode 100644 index 00000000000..5bfb64e36d8 --- /dev/null +++ b/gradle/libs.versions.toml @@ -0,0 +1,460 @@ +# 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. +[versions] +adobe-testing-s3mock = "2.17.0" +amazon-awssdk = "2.26.19" +# @keep Antora version used in ref-guide +antora = "3.1.4" +# @keep Most recent commit as of 2022-06-24, this repo does not have tags +antora-default-ui = "51ad811622394027afb4e182c2fdabc235ae04dd" +# @keep Antora Lunr extensions version used in ref-guide +antora-lunr-extension = "1.0.0-alpha.8" +apache-calcite = "1.37.0" +apache-calcite-avatica = "1.25.0" +apache-commons-collections4 = "4.4" +apache-commons-compress = "1.26.1" +apache-commons-configuration2 = "2.11.0" +apache-commons-exec = "1.4.0" +apache-commons-lang3 = "3.15.0" +apache-commons-math3 = "3.6.1" +# @keep for version alignment +apache-commons-text = "1.12.0" +apache-curator = "5.7.1" +apache-hadoop = "3.4.0" +apache-hadoop-thirdparty = "1.2.0" +apache-httpcomponents-httpclient = "4.5.14" +apache-httpcomponents-httpcore = "4.4.16" +apache-httpcomponents-httpmime = "4.5.14" +apache-kafka = "3.7.1" +apache-kerby = "2.0.3" +apache-log4j = "2.21.0" +apache-lucene = "9.11.1" +apache-opennlp = "1.9.4" +apache-poi = "5.2.2" +apache-rat = "0.15" +apache-tika = "1.28.5" +apache-tomcat = "6.0.53" +apache-zookeeper = "3.9.2" +# @keep for version alignment +apiguardian = "1.1.2" +aqute-bnd = "6.4.1" +# @keep Asciidoctor mathjax version used in ref-guide +asciidoctor-mathjax = "0.0.9" +# @keep Asciidoctor tabs version used in ref-guide +asciidoctor-tabs = "1.0.0-beta.6" +# @keep bats-assert (node) version used in packaging +bats-assert = "2.0.0" +# @keep bats-core (node) version used in packaging +bats-core = "1.8.2" +# @keep bats-file (node) version used in packaging +bats-file = "0.3.0" +bc-jose4j = "0.9.6" +benmanes-caffeine = "3.1.8" +benmanes-versions = "0.51.0" +bouncycastle = "1.78.1" +# @keep Browserify version used in ref-guide +browserify = "17.0.0" +carrot2-core = "4.5.1" +carrotsearch-dependencychecks = "0.0.9" +carrotsearch-hppc = "0.10.0" +carrotsearch-randomizedtesting = "2.8.1" +# @keep for version alignment +checkerframework = "3.44.0" +codehaus-woodstox = "4.2.2" +commons-cli = "1.9.0" +commons-codec = "1.17.1" +commons-collections = "3.2.2" +commons-io = "2.15.1" +cutterslade-analyze = "1.10.0" +cybozulabs-langdetect = "1.1-20120112" +diffplug-spotless = "6.5.2" +dropwizard-metrics = "4.2.26" +eclipse-ecj = "3.39.0" +eclipse-jetty = "10.0.22" +eclipse-jettytoolchain = "4.0.6" +# @keep jgit version used by git-status.gradle +eclipse-jgit = "6.7.0.202309050840-r" +fasterxml = "2.18.0" +fasterxml-woodstox = "7.0.0" +# @keep Flexmark used in classpath +flexmark = "0.64.8" +google-api-gax = "2.33.0" +# @keep for version alignment +google-api-grpc-proto = "2.41.0" +google-auth = "1.19.0" +# @keep for version alignment +google-autovalue = "1.10.4" +google-cloud-bom = "0.224.0" +google-cloud-core = "2.23.0" +google-cloud-nio = "0.127.3" +google-cloud-storage = "2.27.0" +google-errorprone = "2.31.0" +# @keep for version alignment +google-failureaccess = "1.0.2" +# @keep for version alignment +google-gson = "2.11.0" +google-guava = "33.1.0-jre" +# @keep for version alignment +google-j2objc = "3.0.0" +# @keep This is GJF version for spotless/ tidy. +google-javaformat = "1.18.1" +# @keep for version alignment +google-protobuf = "3.25.3" +google-re2j = "1.7" +# @keep Gradle version to run the build +gradle = "8.10" +grpc = "1.65.1" +# @keep Gulp version used in ref-guide +gulp-cli = "2.3.0" +hamcrest = "3.0" +hk2 = "3.1.1" +hsqldb = "2.7.2" +ibm-icu = "74.2" +immutables-valueannotations = "2.10.1" +j256-simplemagic = "1.17" +jakarta-annotation = "2.1.1" +jakarta-inject = "2.0.1" +jakarta-ws = "3.1.0" +# @keep This is the minimum required Java version for the project. +java-min = "21" +# @keep This is the minimum required Java version for SolrJ. +java-solrj = "17" +javacc = "7.0.12" +# @keep for version alignment +jaxb = "2.3.8" +jayway-jsonpath = "2.9.0" +jctools = "4.0.5" +jersey = "3.1.9" +# TODO Sync with jersey versions +jersey-containers = "2.39.1" +# @keep for version alignment +joda-time = "2.8.1" +junit = "4.13.2" +# @keep Link checker version used in ref-guide +link-checker = "1.4.2" +littlerobots-versioncatalogupdate = "0.8.4" +lmax-disruptor = "3.4.4" +ltgt-errorprone = "3.1.0" +mockito = "5.12.0" +morethan-jmhreport = "0.9.0" +navsecurity = "0.5.10" +netty = "4.1.114.Final" +# @keep for version alignment +netty-tcnative = "2.0.66.Final" +nimbusds-josejwt = "9.30.2" +nodegradle-node = "7.0.1" +# @keep Node JS version used in node.gradle (LTS) +nodejs = "16.20.2" +openapi = "7.6.0" +openjdk-jmh = "1.37" +opentelemetry = "1.40.0" +osgi-annotation = "8.1.0" +# @keep for version alignment +ow2-asm = "9.3" +owasp-dependencycheck = "9.0.8" +# @keep for version alignment +perfmark = "0.27.0" +prometheus-metrics = "1.1.0" +prometheus-simpleclient = "0.16.0" +quicktheories = "0.26" +semver4j = "5.3.0" +slf4j = "2.0.13" +spatial4j = "0.8" +spotbugs = "4.8.6" +squareup-okhttp3-mockwebserver = "4.11.0" +squareup-okhttp3-okhttp = "4.12.0" +stephenc-jcip = "1.0-1" +swagger3 = "2.2.22" +tdunning-tdigest = "3.3" +thetaphi-forbiddenapis = "3.7" +thisptr-jacksonjq = "0.0.13" +threeten-bp = "1.6.8" +undercouch-download = "5.5.0" +xerces = "2.12.2" +xerial-snappy = "1.1.10.5" + +[plugins] +benmanes-versions = { id = "com.github.ben-manes.versions", version.ref = "benmanes-versions" } +carrotsearch-dependencychecks = { id = "com.carrotsearch.gradle.dependencychecks", version.ref = "carrotsearch-dependencychecks" } +cutterslade-analyze = { id = "ca.cutterslade.analyze", version.ref = "cutterslade-analyze" } +diffplug-spotless = { id = "com.diffplug.spotless", version.ref = "diffplug-spotless" } +littlerobots-versioncatalogupdate = { id = "nl.littlerobots.version-catalog-update", version.ref = "littlerobots-versioncatalogupdate" } +ltgt-errorprone = { id = "net.ltgt.errorprone", version.ref = "ltgt-errorprone" } +morethan-jmhreport = { id = "io.morethan.jmhreport", version.ref = "morethan-jmhreport" } +nodegradle-node = { id = "com.github.node-gradle.node", version.ref = "nodegradle-node" } +openapi-generator = { id = "org.openapi.generator", version.ref = "openapi" } +owasp-dependencycheck = { id = "org.owasp.dependencycheck", version.ref = "owasp-dependencycheck" } +swagger3-core = { id = "io.swagger.core.v3.swagger-gradle-plugin", version.ref = "swagger3" } +thetaphi-forbiddenapis = { id = "de.thetaphi.forbiddenapis", version.ref = "thetaphi-forbiddenapis" } +undercouch-download = { id = "de.undercouch.download", version.ref = "undercouch-download" } + +[libraries] +adobe-testing-s3mock-junit4 = { module = "com.adobe.testing:s3mock-junit4", version.ref = "adobe-testing-s3mock" } +adobe-testing-s3mock-testsupportcommon = { module = "com.adobe.testing:s3mock-testsupport-common", version.ref = "adobe-testing-s3mock" } +amazon-awssdk-apacheclient = { module = "software.amazon.awssdk:apache-client", version.ref = "amazon-awssdk" } +amazon-awssdk-auth = { module = "software.amazon.awssdk:auth", version.ref = "amazon-awssdk" } +amazon-awssdk-awscore = { module = "software.amazon.awssdk:aws-core", version.ref = "amazon-awssdk" } +amazon-awssdk-bom = { module = "software.amazon.awssdk:bom", version.ref = "amazon-awssdk" } +amazon-awssdk-httpclient-spi = { module = "software.amazon.awssdk:http-client-spi", version.ref = "amazon-awssdk" } +amazon-awssdk-profiles = { module = "software.amazon.awssdk:profiles", version.ref = "amazon-awssdk" } +amazon-awssdk-regions = { module = "software.amazon.awssdk:regions", version.ref = "amazon-awssdk" } +amazon-awssdk-s3 = { module = "software.amazon.awssdk:s3", version.ref = "amazon-awssdk" } +amazon-awssdk-sdkcore = { module = "software.amazon.awssdk:sdk-core", version.ref = "amazon-awssdk" } +amazon-awssdk-sts = { module = "software.amazon.awssdk:sts", version.ref = "amazon-awssdk" } +apache-calcite-avatica-core = { module = "org.apache.calcite.avatica:avatica-core", version.ref = "apache-calcite-avatica" } +apache-calcite-core = { module = "org.apache.calcite:calcite-core", version.ref = "apache-calcite" } +apache-calcite-linq4j = { module = "org.apache.calcite:calcite-linq4j", version.ref = "apache-calcite" } +apache-commons-collections4 = { module = "org.apache.commons:commons-collections4", version.ref = "apache-commons-collections4" } +apache-commons-compress = { module = "org.apache.commons:commons-compress", version.ref = "apache-commons-compress" } +apache-commons-configuration2 = { module = "org.apache.commons:commons-configuration2", version.ref = "apache-commons-configuration2" } +apache-commons-exec = { module = "org.apache.commons:commons-exec", version.ref = "apache-commons-exec" } +apache-commons-lang3 = { module = "org.apache.commons:commons-lang3", version.ref = "apache-commons-lang3" } +apache-commons-math3 = { module = "org.apache.commons:commons-math3", version.ref = "apache-commons-math3" } +# @keep transitive dependency for version alignment +apache-commons-text = { module = "org.apache.commons:commons-text", version.ref = "apache-commons-text" } +apache-curator-client = { module = "org.apache.curator:curator-client", version.ref = "apache-curator" } +apache-curator-framework = { module = "org.apache.curator:curator-framework", version.ref = "apache-curator" } +apache-curator-recipes = { module = "org.apache.curator:curator-recipes", version.ref = "apache-curator" } +apache-curator-test = { module = "org.apache.curator:curator-test", version.ref = "apache-curator" } +apache-hadoop-annotations = { module = "org.apache.hadoop:hadoop-annotations", version.ref = "apache-hadoop" } +apache-hadoop-auth = { module = "org.apache.hadoop:hadoop-auth", version.ref = "apache-hadoop" } +apache-hadoop-client-api = { module = "org.apache.hadoop:hadoop-client-api", version.ref = "apache-hadoop" } +apache-hadoop-client-minicluster = { module = "org.apache.hadoop:hadoop-client-minicluster", version.ref = "apache-hadoop" } +apache-hadoop-client-runtime = { module = "org.apache.hadoop:hadoop-client-runtime", version.ref = "apache-hadoop" } +apache-hadoop-common = { module = "org.apache.hadoop:hadoop-common", version.ref = "apache-hadoop" } +apache-hadoop-hdfs = { module = "org.apache.hadoop:hadoop-hdfs", version.ref = "apache-hadoop" } +apache-hadoop-minikdc = { module = "org.apache.hadoop:hadoop-minikdc", version.ref = "apache-hadoop" } +apache-hadoop-thirdparty-shadedguava = { module = "org.apache.hadoop.thirdparty:hadoop-shaded-guava", version.ref = "apache-hadoop-thirdparty" } +apache-httpcomponents-httpclient = { module = "org.apache.httpcomponents:httpclient", version.ref = "apache-httpcomponents-httpclient" } +apache-httpcomponents-httpcore = { module = "org.apache.httpcomponents:httpcore", version.ref = "apache-httpcomponents-httpcore" } +apache-httpcomponents-httpmime = { module = "org.apache.httpcomponents:httpmime", version.ref = "apache-httpcomponents-httpmime" } +apache-kafka-clients = { module = "org.apache.kafka:kafka-clients", version.ref = "apache-kafka" } +apache-kafka-kafka213 = { module = "org.apache.kafka:kafka_2.13", version.ref = "apache-kafka" } +apache-kafka-server-common = { module = "org.apache.kafka:kafka-server-common", version.ref = "apache-kafka" } +apache-kafka-streams = { module = "org.apache.kafka:kafka-streams", version.ref = "apache-kafka" } +apache-kerby-core = { module = "org.apache.kerby:kerb-core", version.ref = "apache-kerby" } +apache-kerby-util = { module = "org.apache.kerby:kerb-util", version.ref = "apache-kerby" } +apache-log4j-api = { module = "org.apache.logging.log4j:log4j-api", version.ref = "apache-log4j" } +apache-log4j-core = { module = "org.apache.logging.log4j:log4j-core", version.ref = "apache-log4j" } +apache-log4j-jul = { module = "org.apache.logging.log4j:log4j-jul", version.ref = "apache-log4j" } +apache-log4j-layout-templatejson = { module = "org.apache.logging.log4j:log4j-layout-template-json", version.ref = "apache-log4j" } +apache-log4j-slf4j2impl = { module = "org.apache.logging.log4j:log4j-slf4j2-impl", version.ref = "apache-log4j" } +apache-log4j-web = { module = "org.apache.logging.log4j:log4j-web", version.ref = "apache-log4j" } +apache-log4j1-api = { module = "org.apache.logging.log4j:log4j-1.2-api", version.ref = "apache-log4j" } +apache-lucene-analysis-common = { module = "org.apache.lucene:lucene-analysis-common", version.ref = "apache-lucene" } +apache-lucene-analysis-icu = { module = "org.apache.lucene:lucene-analysis-icu", version.ref = "apache-lucene" } +apache-lucene-analysis-kuromoji = { module = "org.apache.lucene:lucene-analysis-kuromoji", version.ref = "apache-lucene" } +apache-lucene-analysis-morfologik = { module = "org.apache.lucene:lucene-analysis-morfologik", version.ref = "apache-lucene" } +apache-lucene-analysis-nori = { module = "org.apache.lucene:lucene-analysis-nori", version.ref = "apache-lucene" } +apache-lucene-analysis-opennlp = { module = "org.apache.lucene:lucene-analysis-opennlp", version.ref = "apache-lucene" } +apache-lucene-analysis-phonetic = { module = "org.apache.lucene:lucene-analysis-phonetic", version.ref = "apache-lucene" } +apache-lucene-analysis-smartcn = { module = "org.apache.lucene:lucene-analysis-smartcn", version.ref = "apache-lucene" } +apache-lucene-analysis-stempel = { module = "org.apache.lucene:lucene-analysis-stempel", version.ref = "apache-lucene" } +apache-lucene-backward-codecs = { module = "org.apache.lucene:lucene-backward-codecs", version.ref = "apache-lucene" } +apache-lucene-classification = { module = "org.apache.lucene:lucene-classification", version.ref = "apache-lucene" } +apache-lucene-codecs = { module = "org.apache.lucene:lucene-codecs", version.ref = "apache-lucene" } +apache-lucene-core = { module = "org.apache.lucene:lucene-core", version.ref = "apache-lucene" } +apache-lucene-expressions = { module = "org.apache.lucene:lucene-expressions", version.ref = "apache-lucene" } +apache-lucene-grouping = { module = "org.apache.lucene:lucene-grouping", version.ref = "apache-lucene" } +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-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" } +apache-lucene-suggest = { module = "org.apache.lucene:lucene-suggest", version.ref = "apache-lucene" } +apache-lucene-testframework = { module = "org.apache.lucene:lucene-test-framework", version.ref = "apache-lucene" } +apache-opennlp-tools = { module = "org.apache.opennlp:opennlp-tools", version.ref = "apache-opennlp" } +apache-poi-ooxml = { module = "org.apache.poi:poi-ooxml", version.ref = "apache-poi" } +apache-poi-poi = { module = "org.apache.poi:poi", version.ref = "apache-poi" } +apache-rat-rat = { module = "org.apache.rat:apache-rat", version.ref = "apache-rat" } +apache-tika-core = { module = "org.apache.tika:tika-core", version.ref = "apache-tika" } +apache-tika-parsers = { module = "org.apache.tika:tika-parsers", version.ref = "apache-tika" } +apache-tomcat-annotationsapi = { module = "org.apache.tomcat:annotations-api", version.ref = "apache-tomcat" } +apache-zookeeper-jute = { module = "org.apache.zookeeper:zookeeper-jute", version.ref = "apache-zookeeper" } +apache-zookeeper-zookeeper = { module = "org.apache.zookeeper:zookeeper", version.ref = "apache-zookeeper" } +# @keep transitive dependency for version alignment +apiguardian-api = { module = "org.apiguardian:apiguardian-api", version.ref = "apiguardian" } +aqute-bnd-annotation = { module = "biz.aQute.bnd:biz.aQute.bnd.annotation", version.ref = "aqute-bnd" } +bc-jose4j = { module = "org.bitbucket.b_c:jose4j", version.ref = "bc-jose4j" } +benmanes-caffeine = { module = "com.github.ben-manes.caffeine:caffeine", version.ref = "benmanes-caffeine" } +bouncycastle-bcpkix = { module = "org.bouncycastle:bcpkix-jdk18on", version.ref = "bouncycastle" } +bouncycastle-bcprov = { module = "org.bouncycastle:bcprov-jdk18on", version.ref = "bouncycastle" } +carrot2-core = { module = "org.carrot2:carrot2-core", version.ref = "carrot2-core" } +carrotsearch-hppc = { module = "com.carrotsearch:hppc", version.ref = "carrotsearch-hppc" } +carrotsearch-randomizedtesting-runner = { module = "com.carrotsearch.randomizedtesting:randomizedtesting-runner", version.ref = "carrotsearch-randomizedtesting" } +# @keep transitive dependency for version alignment +checkerframework-qual = { module = "org.checkerframework:checker-qual", version.ref = "checkerframework" } +codehaus-woodstox-stax2api = { module = "org.codehaus.woodstox:stax2-api", version.ref = "codehaus-woodstox" } +commonscli-commonscli = { module = "commons-cli:commons-cli", version.ref = "commons-cli" } +commonscodec-commonscodec = { module = "commons-codec:commons-codec", version.ref = "commons-codec" } +commonscollections-commonscollections = { module = "commons-collections:commons-collections", version.ref = "commons-collections" } +commonsio-commonsio = { module = "commons-io:commons-io", version.ref = "commons-io" } +cybozulabs-langdetect = { module = "com.cybozu.labs:langdetect", version.ref = "cybozulabs-langdetect" } +dropwizard-metrics-core = { module = "io.dropwizard.metrics:metrics-core", version.ref = "dropwizard-metrics" } +dropwizard-metrics-graphite = { module = "io.dropwizard.metrics:metrics-graphite", version.ref = "dropwizard-metrics" } +dropwizard-metrics-jetty10 = { module = "io.dropwizard.metrics:metrics-jetty10", version.ref = "dropwizard-metrics" } +dropwizard-metrics-jmx = { module = "io.dropwizard.metrics:metrics-jmx", version.ref = "dropwizard-metrics" } +dropwizard-metrics-jvm = { module = "io.dropwizard.metrics:metrics-jvm", version.ref = "dropwizard-metrics" } +dropwizard-metrics-servlets = { module = "io.dropwizard.metrics:metrics-servlets", version.ref = "dropwizard-metrics" } +eclipse-jdt-ecj = { module = "org.eclipse.jdt:ecj", version.ref = "eclipse-ecj" } +eclipse-jetty-alpnjavaclient = { module = "org.eclipse.jetty:jetty-alpn-java-client", version.ref = "eclipse-jetty" } +eclipse-jetty-alpnjavaserver = { module = "org.eclipse.jetty:jetty-alpn-java-server", version.ref = "eclipse-jetty" } +eclipse-jetty-alpnserver = { module = "org.eclipse.jetty:jetty-alpn-server", version.ref = "eclipse-jetty" } +eclipse-jetty-client = { module = "org.eclipse.jetty:jetty-client", version.ref = "eclipse-jetty" } +eclipse-jetty-deploy = { module = "org.eclipse.jetty:jetty-deploy", version.ref = "eclipse-jetty" } +eclipse-jetty-http = { module = "org.eclipse.jetty:jetty-http", version.ref = "eclipse-jetty" } +eclipse-jetty-http2-client = { module = "org.eclipse.jetty.http2:http2-client", version.ref = "eclipse-jetty" } +eclipse-jetty-http2-common = { module = "org.eclipse.jetty.http2:http2-common", version.ref = "eclipse-jetty" } +eclipse-jetty-http2-hpack = { module = "org.eclipse.jetty.http2:http2-hpack", version.ref = "eclipse-jetty" } +eclipse-jetty-http2-httpclienttransport = { module = "org.eclipse.jetty.http2:http2-http-client-transport", version.ref = "eclipse-jetty" } +eclipse-jetty-http2-server = { module = "org.eclipse.jetty.http2:http2-server", version.ref = "eclipse-jetty" } +eclipse-jetty-io = { module = "org.eclipse.jetty:jetty-io", version.ref = "eclipse-jetty" } +eclipse-jetty-jmx = { module = "org.eclipse.jetty:jetty-jmx", version.ref = "eclipse-jetty" } +eclipse-jetty-rewrite = { module = "org.eclipse.jetty:jetty-rewrite", version.ref = "eclipse-jetty" } +eclipse-jetty-security = { module = "org.eclipse.jetty:jetty-security", version.ref = "eclipse-jetty" } +eclipse-jetty-server = { module = "org.eclipse.jetty:jetty-server", version.ref = "eclipse-jetty" } +eclipse-jetty-servlet = { module = "org.eclipse.jetty:jetty-servlet", version.ref = "eclipse-jetty" } +eclipse-jetty-servlets = { module = "org.eclipse.jetty:jetty-servlets", version.ref = "eclipse-jetty" } +eclipse-jetty-start = { module = "org.eclipse.jetty:jetty-start", version.ref = "eclipse-jetty" } +eclipse-jetty-toolchain-servletapi = { module = "org.eclipse.jetty.toolchain:jetty-servlet-api", version.ref = "eclipse-jettytoolchain" } +eclipse-jetty-util = { module = "org.eclipse.jetty:jetty-util", version.ref = "eclipse-jetty" } +eclipse-jetty-webapp = { module = "org.eclipse.jetty:jetty-webapp", version.ref = "eclipse-jetty" } +eclipse-jetty-xml = { module = "org.eclipse.jetty:jetty-xml", version.ref = "eclipse-jetty" } +eclipse-jgit-jgit = { module = "org.eclipse.jgit:org.eclipse.jgit", version.ref = "eclipse-jgit" } +fasterxml-jackson-bom = { module = "com.fasterxml.jackson:jackson-bom", version.ref = "fasterxml" } +fasterxml-jackson-core-annotations = { module = "com.fasterxml.jackson.core:jackson-annotations", version.ref = "fasterxml" } +fasterxml-jackson-core-core = { module = "com.fasterxml.jackson.core:jackson-core", version.ref = "fasterxml" } +fasterxml-jackson-core-databind = { module = "com.fasterxml.jackson.core:jackson-databind", version.ref = "fasterxml" } +fasterxml-jackson-dataformat-cbor = { module = "com.fasterxml.jackson.dataformat:jackson-dataformat-cbor", version.ref = "fasterxml" } +fasterxml-jackson-dataformat-smile = { module = "com.fasterxml.jackson.dataformat:jackson-dataformat-smile", version.ref = "fasterxml" } +fasterxml-woodstox-core = { module = "com.fasterxml.woodstox:woodstox-core", version.ref = "fasterxml-woodstox" } +flexmark-extensions-abbreviation = { module = "com.vladsch.flexmark:flexmark-ext-abbreviation", version.ref = "flexmark" } +flexmark-extensions-attributes = { module = "com.vladsch.flexmark:flexmark-ext-attributes", version.ref = "flexmark" } +flexmark-extensions-autolink = { module = "com.vladsch.flexmark:flexmark-ext-autolink", version.ref = "flexmark" } +flexmark-flexmark = { module = "com.vladsch.flexmark:flexmark", version.ref = "flexmark" } +google-api-gax = { module = "com.google.api:gax", version.ref = "google-api-gax" } +# @keep transitive dependency for version alignment +google-api-grpc-proto = { module = "com.google.api.grpc:proto-google-common-protos", version.ref = "google-api-grpc-proto" } +google-auth-credentials = { module = "com.google.auth:google-auth-library-credentials", version.ref = "google-auth" } +google-auth-oauth2http = { module = "com.google.auth:google-auth-library-oauth2-http", version.ref = "google-auth" } +# @keep transitive dependency for version alignment +google-autovalue-annotations = { module = "com.google.auto.value:auto-value-annotations", version.ref = "google-autovalue" } +google-cloud-bom = { module = "com.google.cloud:google-cloud-bom", version.ref = "google-cloud-bom" } +google-cloud-core = { module = "com.google.cloud:google-cloud-core", version.ref = "google-cloud-core" } +google-cloud-corehttp = { module = "com.google.cloud:google-cloud-core-http", version.ref = "google-cloud-core" } +google-cloud-nio = { module = "com.google.cloud:google-cloud-nio", version.ref = "google-cloud-nio" } +google-cloud-storage = { module = "com.google.cloud:google-cloud-storage", version.ref = "google-cloud-storage" } +# @keep transitive dependency for version alignment +google-errorprone-annotations = { module = "com.google.errorprone:error_prone_annotations", version.ref = "google-errorprone" } +google-errorprone-core = { module = "com.google.errorprone:error_prone_core", version.ref = "google-errorprone" } +# @keep transitive dependency for version alignment +google-gson = { module = "com.google.code.gson:gson", version.ref = "google-gson" } +google-guava = { module = "com.google.guava:guava", version.ref = "google-guava" } +# @keep transitive dependency for version alignment +google-j2objc-annotations = { module = "com.google.j2objc:j2objc-annotations", version.ref = "google-j2objc" } +# @keep transitive dependency for version alignment +google-protobuf-java = { module = "com.google.protobuf:protobuf-java", version.ref = "google-protobuf" } +google-protobuf-javautils = { module = "com.google.protobuf:protobuf-java-util", version.ref = "google-protobuf" } +google-re2j = { module = "com.google.re2j:re2j", version.ref = "google-re2j" } +# @keep transitive dependency for version alignment +grpc-api = { module = "io.grpc:grpc-api", version.ref = "grpc" } +# @keep transitive dependency for version alignment +grpc-bom = { module = "io.grpc:grpc-bom", version.ref = "grpc" } +grpc-context = { module = "io.grpc:grpc-context", version.ref = "grpc" } +# @keep transitive dependency for version alignment +grpc-core = { module = "io.grpc:grpc-core", version.ref = "grpc" } +grpc-netty = { module = "io.grpc:grpc-netty", version.ref = "grpc" } +grpc-protobuf = { module = "io.grpc:grpc-protobuf", version.ref = "grpc" } +# @keep transitive dependency for version alignment +grpc-protobuf-lite = { module = "io.grpc:grpc-protobuf-lite", version.ref = "grpc" } +grpc-stub = { module = "io.grpc:grpc-stub", version.ref = "grpc" } +# @keep transitive dependency for version alignment +grpc-util = { module = "io.grpc:grpc-util", version.ref = "grpc" } +hamcrest-hamcrest = { module = "org.hamcrest:hamcrest", version.ref = "hamcrest" } +hk2-api = { module = "org.glassfish.hk2:hk2-api", version.ref = "hk2" } +# @keep transitive dependency for version alignment +hk2-locator = { module = "org.glassfish.hk2:hk2-locator", version.ref = "hk2" } +hsqldb-hsqldb = { module = "org.hsqldb:hsqldb", version.ref = "hsqldb" } +ibm-icu-icu4j = { module = "com.ibm.icu:icu4j", version.ref = "ibm-icu" } +immutables-valueannotations = { module = "org.immutables:value-annotations", version.ref = "immutables-valueannotations" } +j256-simplemagic = { module = "com.j256.simplemagic:simplemagic", version.ref = "j256-simplemagic" } +jakarta-annotation-api = { module = "jakarta.annotation:jakarta.annotation-api", version.ref = "jakarta-annotation" } +jakarta-inject-api = { module = "jakarta.inject:jakarta.inject-api", version.ref = "jakarta-inject" } +jakarta-ws-rsapi = { module = "jakarta.ws.rs:jakarta.ws.rs-api", version.ref = "jakarta-ws" } +javacc-javacc = { module = "net.java.dev.javacc:javacc", version.ref = "javacc" } +# @keep transitive dependency for version alignment +jaxb-runtime = { module = "org.glassfish.jaxb:jaxb-runtime", version.ref = "jaxb" } +jayway-jsonpath = { module = "com.jayway.jsonpath:json-path", version.ref = "jayway-jsonpath" } +jctools-core = { module = "org.jctools:jctools-core", version.ref = "jctools" } +jersey-containers-jettyhttp = { module = "org.glassfish.jersey.containers:jersey-container-jetty-http", version.ref = "jersey-containers" } +jersey-core-common = { module = "org.glassfish.jersey.core:jersey-common", version.ref = "jersey" } +jersey-core-server = { module = "org.glassfish.jersey.core:jersey-server", version.ref = "jersey" } +jersey-inject-hk2 = { module = "org.glassfish.jersey.inject:jersey-hk2", version.ref = "jersey" } +jersey-media-jsonjackson = { module = "org.glassfish.jersey.media:jersey-media-json-jackson", version.ref = "jersey" } +# @keep transitive dependency for version alignment +jodatime-jodatime = { module = "joda-time:joda-time", version.ref = "joda-time" } +junit-junit = { module = "junit:junit", version.ref = "junit" } +lmax-disruptor = { module = "com.lmax:disruptor", version.ref = "lmax-disruptor" } +locationtech-spatial4j = { module = "org.locationtech.spatial4j:spatial4j", version.ref = "spatial4j" } +mockito-core = { module = "org.mockito:mockito-core", version.ref = "mockito" } +mockito-subclass = { module = "org.mockito:mockito-subclass", version.ref = "mockito" } +navsecurity-mockoauth2server = { module = "no.nav.security:mock-oauth2-server", version.ref = "navsecurity" } +netty-bom = { module = "io.netty:netty-bom", version.ref = "netty" } +netty-codechttp = { module = "io.netty:netty-codec-http", version.ref = "netty" } +# @keep transitive dependency for version alignment +netty-handler = { module = "io.netty:netty-handler", version.ref = "netty" } +# @keep transitive dependency for version alignment +netty-tcnative-boringssl = { module = "io.netty:netty-tcnative-boringssl-static", version.ref = "netty-tcnative" } +netty-tcnative-classes = { module = "io.netty:netty-tcnative-classes", version.ref = "netty-tcnative" } +# @keep transitive dependency for version alignment +netty-transport-classes-epoll = { module = "io.netty:netty-transport-classes-epoll", version.ref = "netty" } +netty-transport-native-epoll = { module = "io.netty:netty-transport-native-epoll", version.ref = "netty" } +nimbusds-josejwt = { module = "com.nimbusds:nimbus-jose-jwt", version.ref = "nimbusds-josejwt" } +openjdk-jmh-core = { module = "org.openjdk.jmh:jmh-core", version.ref = "openjdk-jmh" } +openjdk-jmh-generatorannprocess = { module = "org.openjdk.jmh:jmh-generator-annprocess", version.ref = "openjdk-jmh" } +opentelemetry-api = { module = "io.opentelemetry:opentelemetry-api", version.ref = "opentelemetry" } +opentelemetry-bom = { module = "io.opentelemetry:opentelemetry-bom", version.ref = "opentelemetry" } +opentelemetry-context = { module = "io.opentelemetry:opentelemetry-context", version.ref = "opentelemetry" } +opentelemetry-exporter-otlp = { module = "io.opentelemetry:opentelemetry-exporter-otlp", version.ref = "opentelemetry" } +opentelemetry-sdk = { module = "io.opentelemetry:opentelemetry-sdk", version.ref = "opentelemetry" } +opentelemetry-sdkextension-autoconfigure = { module = "io.opentelemetry:opentelemetry-sdk-extension-autoconfigure", version.ref = "opentelemetry" } +opentelemetry-sdktesting = { module = "io.opentelemetry:opentelemetry-sdk-testing", version.ref = "opentelemetry" } +opentelemetry-sdktrace = { module = "io.opentelemetry:opentelemetry-sdk-trace", version.ref = "opentelemetry" } +osgi-annotation = { module = "org.osgi:osgi.annotation", version.ref = "osgi-annotation" } +# @keep transitive dependency for version alignment +ow2-asm = { module = "org.ow2.asm:asm", version.ref = "ow2-asm" } +# @keep transitive dependency for version alignment +perfmark-api = { module = "io.perfmark:perfmark-api", version.ref = "perfmark" } +prometheus-metrics-expositionformats = { module = "io.prometheus:prometheus-metrics-exposition-formats", version.ref = "prometheus-metrics" } +prometheus-metrics-model = { module = "io.prometheus:prometheus-metrics-model", version.ref = "prometheus-metrics" } +prometheus-simpleclient = { module = "io.prometheus:simpleclient", version.ref = "prometheus-simpleclient" } +prometheus-simpleclient-httpserver = { module = "io.prometheus:simpleclient_httpserver", version.ref = "prometheus-simpleclient" } +quicktheories-quicktheories = { module = "org.quicktheories:quicktheories", version.ref = "quicktheories" } +semver4j-semver4j = { module = "org.semver4j:semver4j", version.ref = "semver4j" } +slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" } +slf4j-jcloverslf4j = { module = "org.slf4j:jcl-over-slf4j", version.ref = "slf4j" } +slf4j-jultoslf4j = { module = "org.slf4j:jul-to-slf4j", version.ref = "slf4j" } +spotbugs-annotations = { module = "com.github.spotbugs:spotbugs-annotations", version.ref = "spotbugs" } +squareup-okhttp3-mockwebserver = { module = "com.squareup.okhttp3:mockwebserver", version.ref = "squareup-okhttp3-mockwebserver" } +squareup-okhttp3-okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "squareup-okhttp3-okhttp" } +stephenc-jcip-annotations = { module = "com.github.stephenc.jcip:jcip-annotations", version.ref = "stephenc-jcip" } +swagger3-annotations-jakarta = { module = "io.swagger.core.v3:swagger-annotations-jakarta", version.ref = "swagger3" } +swagger3-jaxrs2-jakarta = { module = "io.swagger.core.v3:swagger-jaxrs2-jakarta", version.ref = "swagger3" } +tdunning-tdigest = { module = "com.tdunning:t-digest", version.ref = "tdunning-tdigest" } +thisptr-jacksonjq = { module = "net.thisptr:jackson-jq", version.ref = "thisptr-jacksonjq" } +threeten-bp = { module = "org.threeten:threetenbp", version.ref = "threeten-bp" } +xerces-impl = { module = "xerces:xercesImpl", version.ref = "xerces" } +xerial-snappy-java = { module = "org.xerial.snappy:snappy-java", version.ref = "xerial-snappy" } diff --git a/gradle/lucene-dev/lucene-dev-repo-composite.gradle b/gradle/lucene-dev/lucene-dev-repo-composite.gradle index d612b29fe70..62274b32e6c 100644 --- a/gradle/lucene-dev/lucene-dev-repo-composite.gradle +++ b/gradle/lucene-dev/lucene-dev-repo-composite.gradle @@ -104,7 +104,7 @@ if (luceneDevRepo != null) { // We substitute the exact version of Lucene we currently have in versions.props across all the dependencies. // We can't just substitute all references without looking at the versoin because // plugin dependencies then also get substituted and everything crashes. - String luceneVersion = (file("${rootDir}/versions.props").getText("UTF-8") =~ /org.apache.lucene:\*=(.+)/)[0][1] + String luceneVersion = libs.versions.apache.lucene.get() logger.lifecycle("Local Lucene development repository will be used substituting ${luceneVersion}: ${luceneDevRepo}") // Include Lucene repository as a composite and substitute module names. diff --git a/gradle/maven/defaults-maven.gradle b/gradle/maven/defaults-maven.gradle index 49a28dfa8d6..3239c04acfc 100644 --- a/gradle/maven/defaults-maven.gradle +++ b/gradle/maven/defaults-maven.gradle @@ -151,17 +151,6 @@ configure(subprojects.findAll { it.path in rootProject.published }) { prj -> artifact javadocJar pom(configurePom) - - pom({ - // LUCENE-9561: - // Remove dependencyManagement section created by a combination of - // Palantir and the publishing plugin. - // - // https://github.com/palantir/gradle-consistent-versions/issues/550 - withXml { - asNode().dependencyManagement.replaceNode {} - } - }) } } } diff --git a/gradle/node.gradle b/gradle/node.gradle index ff8404c2db2..d585ab5f871 100644 --- a/gradle/node.gradle +++ b/gradle/node.gradle @@ -16,7 +16,7 @@ */ configure([project(":solr:packaging"), project(":solr:solr-ref-guide"), project(":solr:webapp")]) { - apply plugin: "com.github.node-gradle.node" + apply plugin: libs.plugins.nodegradle.node.get().pluginId def npmRegistry = "${ -> propertyOrEnvOrDefault("solr.npm.registry", "SOLR_NPM_REGISTRY", '') }" if (!npmRegistry.isEmpty()) { @@ -41,7 +41,7 @@ configure([project(":solr:packaging"), project(":solr:solr-ref-guide"), project( node { download = true - version = "16.20.2" // LTS + version = libs.versions.nodejs.get() def nodeDistUrl = "${ -> propertyOrEnvOrDefault("solr.node.distUrl", "SOLR_NODE_DIST_URL", '') }" if (!nodeDistUrl.isEmpty()) { diff --git a/gradle/testing/randomization.gradle b/gradle/testing/randomization.gradle index 183943a39e7..d3ae962c144 100644 --- a/gradle/testing/randomization.gradle +++ b/gradle/testing/randomization.gradle @@ -30,7 +30,7 @@ buildscript { } dependencies { - classpath 'com.carrotsearch.randomizedtesting:randomizedtesting-runner:2.7.9' + classpath libs.carrotsearch.randomizedtesting.runner } } diff --git a/gradle/validation/check-environment.gradle b/gradle/validation/check-environment.gradle index 6e5c01ef19c..f56e9fa4e78 100644 --- a/gradle/validation/check-environment.gradle +++ b/gradle/validation/check-environment.gradle @@ -22,7 +22,7 @@ import org.gradle.util.GradleVersion configure(rootProject) { ext { - expectedGradleVersion = '8.10' + expectedGradleVersion = libs.versions.gradle.get() } wrapper { @@ -31,7 +31,7 @@ configure(rootProject) { } def currentJavaVersion = JavaVersion.current() - def minJavaVersion = rootProject.sourceCompatibility// JavaVersion.VERSION_11 // TODO Write out java version + def minJavaVersion = JavaVersion.toVersion(libs.versions.java.min.get()) if (currentJavaVersion < minJavaVersion) { throw new GradleException("At least Java ${minJavaVersion} is required, you are running Java ${currentJavaVersion} " + "[${System.getProperty('java.vm.name')} ${System.getProperty('java.vm.version')}]") diff --git a/gradle/validation/dependencies.gradle b/gradle/validation/dependencies.gradle new file mode 100644 index 00000000000..f83a7d825c6 --- /dev/null +++ b/gradle/validation/dependencies.gradle @@ -0,0 +1,349 @@ +/* + * 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. + */ + +// Helper function for specifying stable versions for dependency updates +// https://github.com/ben-manes/gradle-versions-plugin +def isNonStable = { String version -> + def stableKeyword = ['RELEASE', 'FINAL', 'GA'].any { it -> version.toUpperCase().contains(it) } + def regex = /^[0-9,.v-]+(-r)?$/ + return !stableKeyword && !(version ==~ regex) +} + +// Configure sanity check for conflicting dependencies across certain configurations +allprojects { + apply plugin: libs.plugins.carrotsearch.dependencychecks.get().pluginId + + def consolidatedConfigurations = project.configurations.matching { + it.name in [ + "annotationProcessor", + "compileClasspath", + "libExt", + "packaging", + "runtimeClasspath", + "runtimeLibs", + "server", + "serverLib", + "solrCore", + "solrFullTgz", + "solrPlatformLibs", + "solrSlimTgz", + "testCompileClasspath", + "testRuntimeClasspath", + ] + } + + dependencyVersionChecks { + lockFileComment = "An inventory of resolved dependency versions. Do not edit this file directly." + + configurationGroups { + // consolidated_dependencies is a configuration group that is used + // to check for conflicting versions of the included configurations + consolidated_dependencies { + include consolidatedConfigurations + } + } + } + + dependencies { + modules { + module("org.hamcrest:hamcrest-core") { + replacedBy("org.hamcrest:hamcrest", "hamcrest-core was renamed to hamcrest") + } + } + + constraints { handler -> + consolidatedConfigurations.configureEach { Configuration conf -> + // Add BOMs as they resolve many dependency conflicts + handler.add(conf.name, libs.amazon.awssdk.bom, { + because 'version alignment with known BOM for consistency across project' + }) + handler.add(conf.name, libs.google.cloud.bom, { + because 'version alignment with known BOM for consistency across project' + }) + handler.add(conf.name, libs.fasterxml.jackson.bom, { + because 'version alignment with known BOM for consistency across project' + }) + handler.add(conf.name, libs.opentelemetry.bom, { + because 'version alignment with known BOM for consistency across project' + }) + handler.add(conf.name, libs.grpc.bom, { + because 'version alignment with known BOM for consistency across project' + }) + handler.add(conf.name, libs.netty.bom, { + because 'version alignment with known BOM for consistency across project' + }) + + // Add known dependencies that have multiple versions as constraints + // to align versions + handler.add(conf.name, libs.google.guava, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.google.errorprone.annotations, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.apache.commons.exec, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.xerial.snappy.java, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.grpc.context, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.commonscli.commonscli, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.commonscodec.commonscodec, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.commonsio.commonsio, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.junit.junit, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.grpc.core, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.grpc.protobuf, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.jakarta.annotation.api, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.apache.commons.lang3, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.grpc.stub, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.eclipse.jetty.server, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.fasterxml.woodstox.core, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.slf4j.api, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.slf4j.jultoslf4j, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.apache.commons.compress, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.benmanes.caffeine, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.carrotsearch.hppc, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.apache.log4j.api, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.grpc.api, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.slf4j.jcloverslf4j, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.netty.codechttp, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.bc.jose4j, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.lmax.disruptor, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.apache.httpcomponents.httpclient, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.apache.httpcomponents.httpcore, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.apache.httpcomponents.httpmime, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.apache.kerby.core, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.apache.zookeeper.zookeeper, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.apache.zookeeper.jute, { + because 'version alignment for consistency across project' + }) + handler.add(conf.name, libs.hamcrest.hamcrest, { + because 'version alignment for consistency across project' + }) + + // Add transitive dependencies as constraints to align versions + handler.add(conf.name, libs.checkerframework.qual, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.google.guava)} uses 3.42.0" + + "\n- ${getFullName(libs.benmanes.caffeine)} uses 3.37.0" + + "\n- ${getFullName(libs.google.cloud.storage)} uses 3.44.0" + }) + handler.add(conf.name, libs.ow2.asm, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.apache.lucene.expressions)} uses 7.2" + + "\n- ${getFullName(libs.apache.tika.parsers)} uses 9.3" + }) + handler.add(conf.name, libs.google.protobuf.java, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.google.errorprone.core)} uses 3.19.6" + + "\n- ${getFullName(libs.apache.tika.parsers)} uses 3.21.5" + + "\n- ${getFullName(libs.apache.calcite.avatica.core)} uses 3.21.9" + + "\n- ${getFullName(libs.google.cloud.storage)} uses 3.25.3" + + "\n- ${getFullName(libs.google.cloud.core)} uses 3.25.3" + }) + handler.add(conf.name, libs.google.gson, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.grpc.core)} uses 2.10.1" + + "\n- ${getFullName(libs.apache.tika.parsers)} uses 2.9.1" + + "\n- ${getFullName(libs.google.cloud.storage)} uses 2.11.0 and 2.10.1" + + "\n- ${getFullName(libs.google.protobuf.java)} uses 2.8.9" + + "\n- ${getFullName(libs.google.cloud.core)} uses 2.8.9 and 2.10.1" + + "\n- ${getFullName(libs.google.auth.oauth2http)} uses 2.10.1" + }) + handler.add(conf.name, libs.google.autovalue.annotations, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.google.cloud.storage)} uses 1.10.4" + + "\n- ${getFullName(libs.google.cloud.corehttp)} uses 1.10.4" + + "\n- ${getFullName(libs.google.cloud.core)} uses 1.10.4" + + "\n- ${getFullName(libs.google.api.gax)} uses 1.10.4" + + "\n- ${getFullName(libs.google.auth.oauth2http)} uses 1.10.4" + + "\n- ${getFullName(libs.google.cloud.bom)} uses 1.10.4" + + "\n- ${getFullName(libs.google.errorprone.core)} uses 1.9" + }) + handler.add(conf.name, libs.apache.commons.text, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.apache.calcite.core)} uses 1.11.0" + + "\n- ${getFullName(libs.apache.commons.configuration2)} uses 1.12.0" + }) + handler.add(conf.name, libs.grpc.util, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.google.cloud.storage)} uses 1.62.2" + + "\n- ${getFullName(libs.grpc.netty)} uses 1.65.1" + }) + handler.add(conf.name, libs.jodatime.jodatime, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.amazon.awssdk.sdkcore)} uses 2.8.1" + + "\n- ${getFullName(libs.apache.tika.parsers)} uses 2.2" + }) + handler.add(conf.name, libs.google.api.grpc.proto, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.grpc.protobuf.asProvider())} uses 2.29.0" + + "\n- ${getFullName(libs.google.api.gax)} uses 2.41.0" + + "\n- ${getFullName(libs.google.api.grpc.proto)} uses 2.41.0" + + "\n- ${getFullName(libs.google.cloud.core)} uses 2.41.0" + + "\n- ${getFullName(libs.google.cloud.storage)} uses 2.41.0" + }) + handler.add(conf.name, libs.netty.handler, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.apache.zookeeper.zookeeper)} uses 4.1.105.Final" + + "\n- ${getFullName(libs.netty.codechttp)} uses 4.1.112.Final" + }) + handler.add(conf.name, libs.grpc.protobuf.lite, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.google.cloud.storage)} uses 1.62.2" + + "\n- ${getFullName(libs.grpc.protobuf.asProvider())} uses 1.65.1" + }) + handler.add(conf.name, libs.jaxb.runtime, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.apache.tika.parsers)} uses 2.3.5" + + "\n- ${getFullName(libs.adobe.testing.s3mock.testsupportcommon)} uses 2.3.8" + }) + handler.add(conf.name, libs.perfmark.api, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.grpc.core)} uses 0.26.0" + + "\n- ${getFullName(libs.grpc.netty)} uses 0.26.0" + + "\n- ${getFullName(libs.google.cloud.storage)} uses 0.27.0" + }) + handler.add(conf.name, libs.netty.tcnative.boringssl, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.netty.bom)} uses 2.0.66.Final" + + "\n- ${getFullName(libs.apache.zookeeper.zookeeper)} uses 2.0.61.Final" + }) + handler.add(conf.name, libs.netty.transport.classes.epoll, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.netty.bom)} uses 4.1.114.Final" + + "\n- ${getFullName(libs.apache.zookeeper.zookeeper)} uses 4.1.105.Final" + }) + handler.add(conf.name, libs.netty.transport.native.epoll, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.netty.bom)} uses 4.1.114.Final" + + "\n- ${getFullName(libs.apache.zookeeper.zookeeper)} uses 4.1.105.Final" + }) + handler.add(conf.name, libs.google.j2objc.annotations, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.google.guava)} uses 3.0.0" + + "\n- ${getFullName(libs.google.protobuf.javautils)} uses 2.8" + }) + handler.add(conf.name, libs.apiguardian.api, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.apache.calcite.core)} uses 1.1.2" + + "\n- ${getFullName(libs.junit.junit)} (api) uses 1.1.0" + }) + handler.add(conf.name, libs.hk2.locator, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.jersey.inject.hk2)} uses 3.0.6" + + "\n- ${getFullName(libs.hk2.api)} uses 3.1.1" + }) + } + } + } +} + +static def getFullName(Provider dependency) { + def resolvedDep = dependency.get() + return "${resolvedDep.module.group}:${resolvedDep.module.name}" +} + +// Configure version catalog cleanups plugin. +configure(rootProject) { + apply plugin: libs.plugins.littlerobots.versioncatalogupdate.get().pluginId + + versionCatalogUpdate { + sortByKey = true + } + + tasks.matching { it.name == "tidy" }.configureEach { + it.dependsOn(":versionCatalogFormat") + } + + tasks.matching { + it.path in [":versionCatalogUpdate"] + }.configureEach { + it.interactive = true + } + + tasks.register("updateLibs", { + dependsOn ":versionCatalogUpdate" + }) + + // on dependencyUpdates get only stable versions recommended if current version is stable + // https://github.com/ben-manes/gradle-versions-plugin + tasks.named("dependencyUpdates").configure { + checkConstraints = true + checkBuildEnvironmentConstraints = true + rejectVersionIf { + isNonStable(it.candidate.version) && !isNonStable(it.currentVersion) + } + } +} diff --git a/gradle/validation/dependency-analyze.gradle b/gradle/validation/dependency-analyze.gradle index 1f35012ecf2..92125aba11c 100644 --- a/gradle/validation/dependency-analyze.gradle +++ b/gradle/validation/dependency-analyze.gradle @@ -20,7 +20,7 @@ allprojects { prj -> plugins.withId("java", { - prj.apply plugin: 'ca.cutterslade.analyze' + prj.apply plugin: libs.plugins.cutterslade.analyze.get().pluginId analyzeClassesDependencies { warnUsedUndeclared = false // means fail build if UsedUndeclared found diff --git a/gradle/validation/ecj-lint.gradle b/gradle/validation/ecj-lint.gradle index f47f70587a1..86f30cd5f1f 100644 --- a/gradle/validation/ecj-lint.gradle +++ b/gradle/validation/ecj-lint.gradle @@ -23,7 +23,7 @@ configure(rootProject) { } dependencies { - ecjDeps "org.eclipse.jdt:ecj:${scriptDepVersions['ecj']}" + ecjDeps libs.eclipse.jdt.ecj } } diff --git a/gradle/validation/error-prone.gradle b/gradle/validation/error-prone.gradle index 647ebdeb4fb..2acabf4513c 100644 --- a/gradle/validation/error-prone.gradle +++ b/gradle/validation/error-prone.gradle @@ -37,24 +37,25 @@ if (skipReason) { allprojects { prj -> plugins.withType(JavaPlugin) { - // LUCENE-9650: Errorprone on master/gradle does not work when running as plugin - // inside a forked Javac process. Javac running inside Gradle works, because we have - // additional module system opens in place. - // This is a hack to keep the dependency (so that palantir's version check doesn't complain) - // but don't include the plugin (which fails on JDK16+). + // LUCENE-9650: Errorprone does not work when running as a plugin inside a forked Javac process. + // Javac running inside Gradle works, because we have additional module system opens in place. if (skipReason) { tasks.withType(JavaCompile) { task -> task.dependsOn ":errorProneSkipped" } + + // Error prone plugin adds error prone to test classpath. We need to add it here too + // (manually) so that versions.lock is consistent with or without error prone. configurations { errorprone } dependencies { - errorprone("com.google.errorprone:error_prone_core") + errorprone libs.google.errorprone.core } + configurations.annotationProcessor.extendsFrom(configurations.errorprone) } else { - prj.apply plugin: 'net.ltgt.errorprone' + prj.apply plugin: libs.plugins.ltgt.errorprone.get().pluginId dependencies { - errorprone("com.google.errorprone:error_prone_core") + errorprone libs.google.errorprone.core } tasks.withType(JavaCompile) { task -> diff --git a/gradle/validation/forbidden-apis.gradle b/gradle/validation/forbidden-apis.gradle index 0ffb3a3a272..2a09ff49dda 100644 --- a/gradle/validation/forbidden-apis.gradle +++ b/gradle/validation/forbidden-apis.gradle @@ -23,7 +23,7 @@ def resources = scriptResources(buildscript) // Only apply forbidden-apis to java projects. allprojects { prj -> plugins.withId("java", { - prj.apply plugin: 'de.thetaphi.forbiddenapis' + prj.apply plugin: libs.plugins.thetaphi.forbiddenapis.get().pluginId // This helper method appends signature files based on a set of true // dependencies from a given configuration. diff --git a/gradle/validation/git-status.gradle b/gradle/validation/git-status.gradle index b34cf831ef7..8a43e7c7b3d 100644 --- a/gradle/validation/git-status.gradle +++ b/gradle/validation/git-status.gradle @@ -33,7 +33,7 @@ buildscript { } dependencies { - classpath "org.eclipse.jgit:org.eclipse.jgit:${scriptDepVersions['jgit']}" + classpath libs.eclipse.jgit.jgit } } diff --git a/gradle/validation/jar-checks.gradle b/gradle/validation/jar-checks.gradle index 7547214299d..650a3b3337b 100644 --- a/gradle/validation/jar-checks.gradle +++ b/gradle/validation/jar-checks.gradle @@ -36,7 +36,7 @@ buildscript { } dependencies { - classpath "commons-codec:commons-codec:${scriptDepVersions['commons-codec']}" + classpath libs.commonscodec.commonscodec } } diff --git a/gradle/validation/precommit.gradle b/gradle/validation/precommit.gradle index 8c2fe6cfd98..cc298b8771f 100644 --- a/gradle/validation/precommit.gradle +++ b/gradle/validation/precommit.gradle @@ -23,8 +23,6 @@ configure(rootProject) { description = "All precommit checks" // Root-level validation tasks. - dependsOn ":verifyLocks" - dependsOn ":versionsPropsAreSorted" dependsOn ":checkWorkingCopyClean" // Solr validation tasks. diff --git a/gradle/validation/rat-sources.gradle b/gradle/validation/rat-sources.gradle index 577529a9c16..151aca3b1e9 100644 --- a/gradle/validation/rat-sources.gradle +++ b/gradle/validation/rat-sources.gradle @@ -24,7 +24,7 @@ configure(rootProject) { } dependencies { - ratDeps "org.apache.rat:apache-rat:${scriptDepVersions['apache-rat']}" + ratDeps libs.apache.rat.rat } } diff --git a/gradle/validation/spotless.gradle b/gradle/validation/spotless.gradle index d4444a87671..32234c93a4a 100644 --- a/gradle/validation/spotless.gradle +++ b/gradle/validation/spotless.gradle @@ -22,7 +22,7 @@ configure(allprojects) { prj -> plugins.withType(JavaPlugin) { - prj.apply plugin: 'com.diffplug.spotless' + prj.apply plugin: libs.plugins.diffplug.spotless.get().pluginId project.ext { spotlessJavaSetup = (Action){ @@ -34,7 +34,7 @@ configure(allprojects) { prj -> // it.licenseHeaderFile(file("${resources}/asl-header.txt"), '^(\\s*package)') it.setLineEndings(Enum.valueOf(rootProject.buildscript.classLoader.loadClass("com.diffplug.spotless.LineEnding"), "UNIX")) it.endWithNewline() - it.googleJavaFormat('1.18.1') + it.googleJavaFormat(libs.versions.google.javaformat.get()) it.custom('Refuse wildcard imports', { line -> // Wildcard imports can't be resolved by spotless itself. diff --git a/gradle/validation/validate-source-patterns.gradle b/gradle/validation/validate-source-patterns.gradle index ec44c804a9b..9c4c93353e0 100644 --- a/gradle/validation/validate-source-patterns.gradle +++ b/gradle/validation/validate-source-patterns.gradle @@ -29,7 +29,7 @@ buildscript { } dependencies { - classpath "org.apache.rat:apache-rat:${scriptDepVersions['apache-rat']}" + classpath libs.apache.rat.rat } } diff --git a/gradle/validation/versions-props-sorted.gradle b/gradle/validation/versions-props-sorted.gradle deleted file mode 100644 index 3282faf8391..00000000000 --- a/gradle/validation/versions-props-sorted.gradle +++ /dev/null @@ -1,35 +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. - */ - -// This ensures 'versions.props' file is sorted lexicographically. - -import java.util.stream.Collectors - -configure(rootProject) { - task versionsPropsAreSorted() { - doFirst { - def versionsProps = file('versions.props') - // remove # commented lines and blank lines - def lines = versionsProps.readLines("UTF-8").stream().filter(l -> !l.matches(/^(#.*|\s*)$/)).collect(Collectors.toList()) - def sorted = lines.toSorted() - - if (!Objects.equals(lines, sorted)) { - throw new GradleException("${versionsProps} file is not sorted lexicographically.") - } - } - } -} diff --git a/help/dependencies.txt b/help/dependencies.txt index c1c81c560b0..fd1bc68b711 100644 --- a/help/dependencies.txt +++ b/help/dependencies.txt @@ -7,7 +7,7 @@ and each configuration can have dependencies attached to it. There are some standard conventions so, for example, the Java plugin adds standard configurations such as "api", "implementation", "testImplementation" and others. These configurations can also inherit -from each other; more about this typic can be found here: +from each other; more about this topic can be found here: https://docs.gradle.org/current/userguide/dependency_management_for_java_projects.html#dependency_management_for_java_projects https://docs.gradle.org/current/userguide/java_library_plugin.html#sec:java_library_separation @@ -29,60 +29,126 @@ testImplementation - makes a dependency only available for test classes. Adding a library dependency --------------------------- -Let's say we wish to add a dependency on library "foo.bar:baz" in +Let's say we wish to add a new dependency on library "foo.bar:baz" in version 1.2 to :solr:core. Let's assume this library is only -used internally by the project. The :solr:core project is configured -by solr/core/build.gradle and we would add (or modify) the dependency -block as follows: +used internally by the project. For new dependencies, we would add +the dependency and its version to gradle/libs.versions.toml first: + +[versions] +... +foo-bar-baz = "1.2" +... + +[libraries] +... +foo-bar-baz = { module = "foo.bar:baz", version.ref = "foo-bar-baz" } + +Note that the used names separated by dashes are later referenced with dots +instead of dashes, but more on that later. + +The chosen name for the module should more or less reflect the module's +group name and module id in a way that it groups related dependencies under +the same "prefix" (see below). There is no specific convention here and +group prefixes for domain names like "com" and "io" are avoided, as they +do not add any value and increase the size of the reference / alias name. + +The :solr:core project is configured by solr/core/build.gradle, and we would +add (or modify) the dependency block as follows: dependencies { - implementation "foo.bar:baz" + implementation libs.foo.bar.baz } +In the project we use the default name "libs" that is used to reference +the version catalog gradle/libs.versions.toml. + The "implementation" here is a named configuration; we don't need to declare it because it is declared for us by the java-library plugin. -In "normal" gradle the version of the dependency would be present -directly inside the declaration but we use a plugin -(palantir-consistent-versions) to manage all dependency versions -from the top-level (so that conflicts can be resolved globally). +In case the IDE does not auto-completes the reference, you may have +to sync your project so that the newly added library is found. -If this is the first time "foo.bar:baz" is added to the project, we'd have -to add its version to "versions.props" file at the top level of the -checkout: +As mentioned before, we can use the dashes to group related libraries +together. So let's assume we have another dependency on "foo.bar:biz", +which is part of the same project as "foo.bar:baz" and therefore share +the same version. -foo.bar:baz=1.2 +In this case we would want to use the same version for both libraries +and add them as follows to the version catalog gradle/libs.versions.toml: -and then regenerate the "versions.lock" file using the following -command: +[versions] +... +foo-bar = "1.2" # Use a shared name for both libraries +... -gradlew --write-locks +[libraries] +... +foo-bar-biz = { module = "foo.bar:biz", version.ref = "foo-bar" } +foo-bar-baz = { module = "foo.bar:baz", version.ref = "foo-bar" } -IMPORTANT: The versions.lock file will contain the actual version -of the dependency picked based on other project dependencies and -their transitive dependencies. This selected version may be -different from what each of these actually requires (the highest -version number will be typically selected). To see which dependencies -require which version of the library use: +This way, both libraries use the same version reference and updates +would affect both. -gradlew why --hash=... +Adding new libraries requires additional actions. The first you want +to do is to run versionCatalogFormat to sort the version catalog. -where the hash code comes from versions.lock file. For example, at -the time of writing, jackson-databind has the following entry: +This command does also remove unused libraries. You can use "# @keep" +with a reason why the library should not be removed. This is sometimes +necessary if the usage of a library is not identified by the plugin, +like when using it with "classpath [dependency]". -com.fasterxml.jackson.core:jackson-databind:2.10.0 (3 constraints: 931a7796) +The next you want to regenerate the "versions.lock" file using the +following command: -and "gradlew why --hash=931a7796" prints: +gradlew writeLocks -com.fasterxml.jackson.core:jackson-databind:2.10.0 - projects -> 2.10.0 - net.thisptr:jackson-jq -> 2.7.0 - org.carrot2:carrot2-mini -> 2.9.9.3 +Since we are responsible to provide and maintain the versions of +libraries, the lock file will reflect the versions of the version +catalog. -Once the dependency is added it always makes sense to see the -tree of all module dependencies and maybe exclude transitive -dependencies of foo.bar:baz that we won't need. +The locking will fail if multiple versions of the same dependency are found. +This may be the case if libraries have a used library as transitive +dependency with a different version. If that is the case, you have to add +a constraint to the modules in gradle/dependencies.gradle with a reason +why the constraint is applied. The below example adds a constraint for +"foo.bar:baz" with the given version from the version catalog, enforcing +the version to all transitive dependencies as well: +dependencies { + ... + constraints { handler -> + consolidatedConfigurations.configureEach { Configuration conf -> + ... + handler.add(conf.name, libs.foo.bar.baz, { + because 'version alignment for consistency across project' + }) + } + } +} + +Because the constraints have to be maintained by the contributors and cleaned +up manually, you should always provide additional information why the constraint +is needed. This information may include the current version of the libraries +that add transitively the dependency of the constraint. This helps others later +find and cleanup constraints if they update dependencies that use newer versions +of the conflicting dependency. For example: + +handler.add(conf.name, libs.ow2.asm, { + because "transitive version alignment for consistency across project" + + "\n- ${getFullName(libs.apache.lucene.expressions)} uses 7.2" + + "\n- ${getFullName(libs.apache.tika.parsers)} uses 9.3" + }) + +In this case, the module org.ow2.asm:asm is used by both org.apache.lucene:lucene-expressions +and org.apache.tika:tika-parsers, but with completely different versions. +The constraint syncs the transitive dependency and lets the maintainers know +which dependencies use it. So if at some point someone else updates the +lucene-expressions to a newer version that uses asm version 9.3, the constraint +would be obsolete and could be removed. + +The hashes from the versions.lock file can be used to look up +which modules use a specific library. Simply look up the hash in the +versions.lock and you will find a group of modules that use it. Update Lucene prerelease ------------------------ @@ -100,12 +166,12 @@ If you want to upgrade Lucene to a newer build proceed like the following: queued) - remember the build number of Jenkins (left side, first build in list, prefixed by '#') -- Edit ./versions.props and change Lucene's version to '9.0.0-prereleaseX', +- Edit gradle/libs.versions.toml and change Lucene's version to '9.0.0-prereleaseX', with 'X' is the jenkins build number - Edit ./gradle/globals.gradle and change jenkins build number, too (this directs the repository to the one created by latest build): def lucenePrereleaseBuild = 'X' -- Run: gradlew --write-locks (as described before) +- Run: gradlew writeLocks (as described before) Lucene local dependency substitution @@ -173,7 +239,7 @@ crucial for the functioning of "foo.bar:baz". We can exclude it by adding an exclusion block to the original declaration: dependencies { - implementation("foo.bar:baz", { + implementation(libs.foo.bar.biz, { exclude group: "foo.bar", module: "irrelevant" }) } @@ -194,3 +260,31 @@ gradlew licenses To update JAR checksums (sha1) for licenses use: gradlew updateLicenses + +Note that this Gradle task does only update the checksums and does not make +any changes to license or notice files. + +Whenever the library's LICENSE or NOTICE file changes, these changes should +be reflected in our copies under solr/licenses. Currently it is necessary to +manually review and update these files. This process is subject to change, +progress can be tracked in SOLR-15929. + +License and notice files may be picked from the libraries' repositories. +When looking up the libraries in Maven Central (https://search.maven.org) +almost all projects have a direct reference to the source code (right side), +usually a GitHub repository, where you can find the License and Notice file +in the root directory. + +Remember to check out the correct tag / release before copying any license +or notice file. Some multi-module projects that publish multiple artifacts +may have subdirectories for each artifact. These directories sometimes +hold a different license for that specific artifact, so make sure to copy +the right license file. Other multi-module projects may have only a single +license and notice file for all modules, like netty, so multiple dependencies +fromt he same group may reference the same license and notice file. + +Other places where you may find a license and notice file are in the pom.xml +file as a URL under a tag if there is no reference to a repository +in Maven Central, or in the artifact downloaded by maven when the library +is added as a dependency (in IntelliJ IDEA the libraries can be found +in the project view under External Libraries at the bottom). diff --git a/settings-gradle.lockfile b/settings-gradle.lockfile new file mode 100644 index 00000000000..709a43f74f8 --- /dev/null +++ b/settings-gradle.lockfile @@ -0,0 +1,4 @@ +# This is a Gradle generated file for dependency locking. +# Manual edits can break the build and are not advised. +# This file is expected to be part of source control. +empty=incomingCatalogForLibs0 diff --git a/solr/api/build.gradle b/solr/api/build.gradle index 1f8118116c6..adad0302602 100644 --- a/solr/api/build.gradle +++ b/solr/api/build.gradle @@ -16,8 +16,8 @@ */ plugins { - id 'io.swagger.core.v3.swagger-gradle-plugin' version '2.2.2' - id "org.openapi.generator" version "6.0.1" + alias(libs.plugins.swagger3.core) + alias(libs.plugins.openapi.generator) } apply plugin: 'java-library' @@ -58,18 +58,18 @@ resolve { } dependencies { - runtimeOnly 'org.slf4j:slf4j-api' + runtimeOnly libs.slf4j.api - implementation 'jakarta.ws.rs:jakarta.ws.rs-api' - implementation 'com.fasterxml.jackson.core:jackson-annotations' - api 'io.swagger.core.v3:swagger-annotations-jakarta' - implementation 'org.semver4j:semver4j' + implementation libs.jakarta.ws.rsapi + implementation libs.fasterxml.jackson.core.annotations + api libs.swagger3.annotations.jakarta + implementation libs.semver4j.semver4j testImplementation project(':solr:test-framework') testImplementation project(':solr:api') - testImplementation 'org.apache.lucene:lucene-test-framework' + testImplementation libs.apache.lucene.testframework - swaggerBuild 'io.swagger.core.v3:swagger-jaxrs2-jakarta' + swaggerBuild libs.swagger3.jaxrs2.jakarta } // Non-Java client generation tasks below: diff --git a/solr/benchmark/build.gradle b/solr/benchmark/build.gradle index 63cea7af01f..fe0b0f44e22 100644 --- a/solr/benchmark/build.gradle +++ b/solr/benchmark/build.gradle @@ -16,16 +16,13 @@ */ plugins { - id "io.morethan.jmhreport" version "0.9.0" - // id 'com.github.johnrengelman.shadow' version '6.1.0' + alias(libs.plugins.morethan.jmhreport) + // generally, you use or have the option to use jmh with a 'fat' jar - currently there + // are some issues to track down to allow that, but this sets up for it + // alias(libs.plugins.johnrengelman.shadow) + id 'java-library' } -// generally, you use or have the option to use jmh with a 'fat' jar - currently there -// are some issues to track down to allow that, but this sets up for it -//apply plugin: 'com.github.johnrengelman.shadow' - -apply plugin: 'java-library' - description = 'Solr Benchmark Framework' //shadowJar { @@ -48,15 +45,15 @@ dependencies { implementation project(':solr:solrj') implementation project(':solr:solrj-streaming') - implementation 'org.apache.lucene:lucene-core' - implementation 'org.apache.httpcomponents:httpclient' - implementation 'commons-io:commons-io' - implementation 'io.dropwizard.metrics:metrics-core' - implementation 'org.apache.commons:commons-math3' - implementation 'org.jctools:jctools-core' - implementation 'org.quicktheories:quicktheories' - implementation 'org.openjdk.jmh:jmh-core' - implementation 'org.slf4j:slf4j-api' - runtimeOnly 'com.lmax:disruptor' - annotationProcessor 'org.openjdk.jmh:jmh-generator-annprocess' + implementation libs.apache.lucene.core + implementation libs.apache.httpcomponents.httpclient + implementation libs.commonsio.commonsio + implementation libs.dropwizard.metrics.core + implementation libs.apache.commons.math3 + implementation libs.jctools.core + implementation libs.quicktheories.quicktheories + implementation libs.openjdk.jmh.core + implementation libs.slf4j.api + runtimeOnly libs.lmax.disruptor + annotationProcessor libs.openjdk.jmh.generatorannprocess } diff --git a/solr/core/build.gradle b/solr/core/build.gradle index 92bbfbe1120..f406f842201 100644 --- a/solr/core/build.gradle +++ b/solr/core/build.gradle @@ -23,187 +23,187 @@ dependencies { // Spotbugs Annotations are only needed for old findbugs // annotation usage like in Zookeeper during compilation time. // It is not included in the release so exclude from checks. - compileOnly 'com.github.spotbugs:spotbugs-annotations' - testCompileOnly 'com.github.spotbugs:spotbugs-annotations' - permitUnusedDeclared 'com.github.spotbugs:spotbugs-annotations' + compileOnly libs.spotbugs.annotations + testCompileOnly libs.spotbugs.annotations + permitUnusedDeclared libs.spotbugs.annotations // Exclude these from jar validation and license checks. configurations.jarValidation { exclude group: "com.github.spotbugs", module: "spotbugs-annotations" } - implementation 'io.swagger.core.v3:swagger-annotations-jakarta' + implementation libs.swagger3.annotations.jakarta // Export these dependencies so that they're imported transitively by // other modules. // These Lucene modules are the most significant to Solr - api "org.apache.lucene:lucene-core" - api "org.apache.lucene:lucene-analysis-common" - api "org.apache.lucene:lucene-queries" + api libs.apache.lucene.core + api libs.apache.lucene.analysis.common + api libs.apache.lucene.queries // We export logging api with dependencies, which is useful for all modules - api 'org.slf4j:slf4j-api' + api libs.slf4j.api api project(':solr:api') api project(':solr:solrj') api project(':solr:solrj-zookeeper') api project(':solr:solrj-streaming') - api 'io.dropwizard.metrics:metrics-core' - implementation ('io.dropwizard.metrics:metrics-graphite', { + api libs.dropwizard.metrics.core + implementation (libs.dropwizard.metrics.graphite, { exclude group: "com.rabbitmq", module: "amqp-client" }) - implementation 'io.dropwizard.metrics:metrics-jmx' - implementation 'io.dropwizard.metrics:metrics-jvm' + implementation libs.dropwizard.metrics.jmx + implementation libs.dropwizard.metrics.jvm - implementation('org.glassfish.jersey.containers:jersey-container-jetty-http', { + implementation(libs.jersey.containers.jettyhttp, { exclude group: "org.eclipse.jetty", module: "jetty-continuation" exclude group: "org.glassfish.hk2.external", module: "jakarta.inject" }) - permitUnusedDeclared 'org.glassfish.jersey.containers:jersey-container-jetty-http' - implementation 'org.glassfish.jersey.inject:jersey-hk2' - permitUnusedDeclared 'org.glassfish.jersey.inject:jersey-hk2' - implementation ('org.glassfish.jersey.media:jersey-media-json-jackson', { + permitUnusedDeclared libs.jersey.containers.jettyhttp + implementation libs.jersey.inject.hk2 + permitUnusedDeclared libs.jersey.inject.hk2 + implementation (libs.jersey.media.jsonjackson, { exclude group: "jakarta.xml.bind", module: "jakarta.xml.bind-api" }) - permitUnusedDeclared 'org.glassfish.jersey.media:jersey-media-json-jackson' - implementation 'org.glassfish.jersey.core:jersey-common' - implementation 'org.glassfish.jersey.core:jersey-server' - implementation 'org.glassfish.hk2:hk2-api' - implementation 'jakarta.inject:jakarta.inject-api' - implementation 'jakarta.ws.rs:jakarta.ws.rs-api' - implementation 'jakarta.annotation:jakarta.annotation-api' + permitUnusedDeclared libs.jersey.media.jsonjackson + implementation libs.jersey.core.common + implementation libs.jersey.core.server + implementation libs.hk2.api + implementation libs.jakarta.inject.api + implementation libs.jakarta.ws.rsapi + implementation libs.jakarta.annotation.api // Non-API below; although there are exceptions - runtimeOnly "org.apache.lucene:lucene-analysis-kuromoji" - runtimeOnly "org.apache.lucene:lucene-analysis-nori" - runtimeOnly "org.apache.lucene:lucene-analysis-phonetic" - runtimeOnly "org.apache.lucene:lucene-backward-codecs" - implementation "org.apache.lucene:lucene-codecs" - implementation "org.apache.lucene:lucene-backward-codecs" - permitUnusedDeclared "org.apache.lucene:lucene-backward-codecs" - implementation "org.apache.lucene:lucene-classification" - implementation "org.apache.lucene:lucene-expressions" - implementation "org.apache.lucene:lucene-grouping" - implementation "org.apache.lucene:lucene-highlighter" - implementation "org.apache.lucene:lucene-join" - implementation "org.apache.lucene:lucene-misc" - implementation "org.apache.lucene:lucene-queryparser" - implementation "org.apache.lucene:lucene-spatial-extras" - implementation "org.apache.lucene:lucene-suggest" + runtimeOnly libs.apache.lucene.analysis.kuromoji + runtimeOnly libs.apache.lucene.analysis.nori + runtimeOnly libs.apache.lucene.analysis.phonetic + runtimeOnly libs.apache.lucene.backward.codecs + implementation libs.apache.lucene.codecs + implementation libs.apache.lucene.backward.codecs + permitUnusedDeclared libs.apache.lucene.backward.codecs + implementation libs.apache.lucene.classification + implementation libs.apache.lucene.expressions + implementation libs.apache.lucene.grouping + implementation libs.apache.lucene.highlighter + implementation libs.apache.lucene.join + implementation libs.apache.lucene.misc + implementation libs.apache.lucene.queryparser + implementation libs.apache.lucene.spatialextras + implementation libs.apache.lucene.suggest // Collections & lang utilities - implementation 'com.google.guava:guava' - implementation 'org.apache.commons:commons-lang3' - implementation 'org.apache.commons:commons-math3' - implementation 'commons-io:commons-io' - implementation 'com.carrotsearch:hppc' + implementation libs.google.guava + implementation libs.apache.commons.lang3 + implementation libs.apache.commons.math3 + implementation libs.commonsio.commonsio + implementation libs.carrotsearch.hppc - implementation('com.github.ben-manes.caffeine:caffeine') { transitive = false } + implementation(libs.benmanes.caffeine) { transitive = false } - implementation 'commons-codec:commons-codec' + implementation libs.commonscodec.commonscodec - implementation 'commons-cli:commons-cli' + implementation libs.commonscli.commonscli - implementation 'org.locationtech.spatial4j:spatial4j' + implementation libs.locationtech.spatial4j - implementation 'com.fasterxml.jackson.core:jackson-annotations' - implementation 'com.fasterxml.jackson.core:jackson-core' - implementation 'com.fasterxml.jackson.core:jackson-databind' - implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-smile' - implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-cbor' + implementation libs.fasterxml.jackson.core.annotations + implementation libs.fasterxml.jackson.core.core + implementation libs.fasterxml.jackson.core.databind + implementation libs.fasterxml.jackson.dataformat.smile + implementation libs.fasterxml.jackson.dataformat.cbor - implementation 'org.apache.httpcomponents:httpclient' - implementation 'org.apache.httpcomponents:httpcore' + implementation libs.apache.httpcomponents.httpclient + implementation libs.apache.httpcomponents.httpcore - implementation 'org.eclipse.jetty:jetty-client' - implementation 'org.eclipse.jetty:jetty-http' - implementation 'org.eclipse.jetty:jetty-io' - implementation 'org.eclipse.jetty.toolchain:jetty-servlet-api' + implementation libs.eclipse.jetty.client + implementation libs.eclipse.jetty.http + implementation libs.eclipse.jetty.io + implementation libs.eclipse.jetty.toolchain.servletapi // ZooKeeper - implementation('org.apache.curator:curator-framework', { + implementation(libs.apache.curator.framework, { exclude group: 'org.apache.zookeeper', module: 'zookeeper' }) - implementation('org.apache.curator:curator-client', { + implementation(libs.apache.curator.client, { exclude group: 'org.apache.zookeeper', module: 'zookeeper' }) - testImplementation('org.apache.curator:curator-test', { + testImplementation(libs.apache.curator.test, { exclude group: 'org.apache.zookeeper', module: 'zookeeper' }) - implementation('org.apache.zookeeper:zookeeper', { + implementation(libs.apache.zookeeper.zookeeper, { exclude group: "org.apache.yetus", module: "audience-annotations" }) - implementation('org.apache.zookeeper:zookeeper-jute') { + implementation(libs.apache.zookeeper.jute) { exclude group: 'org.apache.yetus', module: 'audience-annotations' } - testImplementation 'org.apache.zookeeper:zookeeper::tests' + testImplementation variantOf(libs.apache.zookeeper.zookeeper) { classifier 'tests' } // required for instantiating a Zookeeper server (for embedding ZK or running tests) - runtimeOnly ('org.xerial.snappy:snappy-java') + runtimeOnly libs.xerial.snappy.java - implementation('com.jayway.jsonpath:json-path', { + implementation(libs.jayway.jsonpath, { exclude group: "net.minidev", module: "json-smart" }) // StatsComponents percentiles - implementation 'com.tdunning:t-digest' + implementation libs.tdunning.tdigest // Distributed Tracing - api 'io.opentelemetry:opentelemetry-api' // Tracer is exposed on some methods - implementation 'io.opentelemetry:opentelemetry-context' + api libs.opentelemetry.api // Tracer is exposed on some methods + implementation libs.opentelemetry.context - implementation 'org.apache.commons:commons-exec' + implementation libs.apache.commons.exec - implementation 'org.apache.logging.log4j:log4j-api' - implementation 'org.apache.logging.log4j:log4j-core' - runtimeOnly 'org.apache.logging.log4j:log4j-slf4j2-impl' + implementation libs.apache.log4j.api + implementation libs.apache.log4j.core + runtimeOnly libs.apache.log4j.slf4j2impl // For the PrometheusResponseWriter - implementation 'io.prometheus:prometheus-metrics-model:1.1.0' - implementation('io.prometheus:prometheus-metrics-exposition-formats:1.1.0', { + implementation libs.prometheus.metrics.model + implementation(libs.prometheus.metrics.expositionformats, { exclude group: "io.prometheus", module: "prometheus-metrics-shaded-protobuf" exclude group: "io.prometheus", module: "prometheus-metrics-config" }) // For faster XML processing than the JDK - implementation 'org.codehaus.woodstox:stax2-api' - implementation 'com.fasterxml.woodstox:woodstox-core' + implementation libs.codehaus.woodstox.stax2api + implementation libs.fasterxml.woodstox.core // See https://issues.apache.org/jira/browse/LOG4J2-3609 due to needing these annotations - compileOnly 'biz.aQute.bnd:biz.aQute.bnd.annotation' - compileOnly 'org.osgi:osgi.annotation' + compileOnly libs.aqute.bnd.annotation + compileOnly libs.osgi.annotation - compileOnly 'com.github.stephenc.jcip:jcip-annotations' + compileOnly libs.stephenc.jcip.annotations - implementation 'com.j256.simplemagic:simplemagic' + implementation libs.j256.simplemagic // -- Test Dependencies - testRuntimeOnly 'org.slf4j:jcl-over-slf4j' + testRuntimeOnly libs.slf4j.jcloverslf4j - testRuntimeOnly "org.apache.lucene:lucene-analysis-icu" + testRuntimeOnly libs.apache.lucene.analysis.icu testRuntimeOnly project(':solr:modules:analysis-extras') testImplementation project(':solr:core') testImplementation project(':solr:test-framework') - testImplementation 'org.apache.lucene:lucene-test-framework' + testImplementation libs.apache.lucene.testframework - testImplementation 'org.eclipse.jetty:jetty-server' - testImplementation 'org.eclipse.jetty:jetty-servlet' + testImplementation libs.eclipse.jetty.server + testImplementation libs.eclipse.jetty.servlet - testImplementation 'com.carrotsearch.randomizedtesting:randomizedtesting-runner' - testImplementation 'junit:junit' - testImplementation 'org.hamcrest:hamcrest' + testImplementation libs.carrotsearch.randomizedtesting.runner + testImplementation libs.junit.junit + testImplementation libs.hamcrest.hamcrest - testImplementation('org.mockito:mockito-core', { + testImplementation(libs.mockito.core, { exclude group: "net.bytebuddy", module: "byte-buddy-agent" }) - testRuntimeOnly('org.mockito:mockito-subclass', { + testRuntimeOnly(libs.mockito.subclass, { exclude group: "net.bytebuddy", module: "byte-buddy-agent" }) } diff --git a/solr/cross-dc-manager/build.gradle b/solr/cross-dc-manager/build.gradle index b6cc162525e..1cf2b575b65 100644 --- a/solr/cross-dc-manager/build.gradle +++ b/solr/cross-dc-manager/build.gradle @@ -27,33 +27,49 @@ dependencies { implementation project(':solr:solrj-zookeeper') implementation project(':solr:modules:cross-dc') - implementation 'io.dropwizard.metrics:metrics-core' - implementation 'io.dropwizard.metrics:metrics-servlets' - implementation 'org.eclipse.jetty:jetty-server' - implementation 'org.eclipse.jetty:jetty-servlet' - implementation 'org.slf4j:slf4j-api' - runtimeOnly ('com.google.protobuf:protobuf-java-util') - runtimeOnly ('commons-codec:commons-codec') + implementation libs.dropwizard.metrics.core + implementation libs.dropwizard.metrics.servlets + implementation libs.eclipse.jetty.server + implementation libs.eclipse.jetty.servlet + implementation libs.slf4j.api + runtimeOnly libs.google.protobuf.javautils + runtimeOnly libs.commonscodec.commonscodec - implementation 'org.apache.kafka:kafka-clients' - runtimeOnly 'org.apache.kafka:kafka_2.13' - runtimeOnly 'org.apache.kafka:kafka-streams' + implementation libs.apache.kafka.clients + runtimeOnly libs.apache.kafka.kafka213 + runtimeOnly libs.apache.kafka.streams - runtimeOnly 'org.apache.logging.log4j:log4j-api' - runtimeOnly 'org.apache.logging.log4j:log4j-core' - runtimeOnly 'org.apache.logging.log4j:log4j-slf4j2-impl' - runtimeOnly 'com.lmax:disruptor' + runtimeOnly libs.apache.log4j.api + runtimeOnly libs.apache.log4j.core + runtimeOnly libs.apache.log4j.slf4j2impl + runtimeOnly libs.lmax.disruptor testImplementation project(':solr:test-framework') - testImplementation 'org.apache.lucene:lucene-test-framework' - testImplementation 'com.carrotsearch.randomizedtesting:randomizedtesting-runner' - testImplementation 'junit:junit' - testImplementation 'org.mockito:mockito-core' + testImplementation libs.apache.lucene.testframework + testImplementation libs.carrotsearch.randomizedtesting.runner + testImplementation libs.junit.junit + testImplementation libs.mockito.core - testImplementation 'org.apache.kafka:kafka-streams:3.7.1:test' - testImplementation 'org.apache.kafka:kafka-clients:3.7.1:test' - testRuntimeOnly 'org.apache.kafka:kafka_2.13:3.7.1:test' - testRuntimeOnly 'org.apache.kafka:kafka-server-common:3.7.1:test' + testImplementation(libs.apache.kafka.streams) { + artifact { + classifier = "test" + } + } + testImplementation(libs.apache.kafka.clients) { + artifact { + classifier = "test" + } + } + testRuntimeOnly(libs.apache.kafka.kafka213) { + artifact { + classifier = "test" + } + } + testRuntimeOnly(libs.apache.kafka.server.common) { + artifact { + classifier = "test" + } + } } ext { diff --git a/solr/docker/build.gradle b/solr/docker/build.gradle index cf360908bb2..6c3417504d8 100644 --- a/solr/docker/build.gradle +++ b/solr/docker/build.gradle @@ -22,7 +22,7 @@ import org.apache.commons.codec.digest.DigestUtils description = 'Solr Docker image' apply plugin: 'base' -def javaVersion = scriptDepVersions['min-java-version'] +def javaVersion = libs.versions.java.min.get() // Solr Docker inputs def dockerImageSolrDist = "${ -> propertyOrEnvOrDefault("solr.docker.dist", "SOLR_DOCKER_DIST", 'full') }" def isDistSlim = {String dist -> dist.toLowerCase(Locale.ROOT) == "slim"} @@ -127,7 +127,7 @@ buildscript { mavenCentral() } dependencies { - classpath "commons-codec:commons-codec:${scriptDepVersions['commons-codec']}" + classpath libs.commonscodec.commonscodec } } def checksum = { file -> diff --git a/solr/licenses/hamcrest-core-3.0.jar.sha1 b/solr/licenses/hamcrest-core-3.0.jar.sha1 deleted file mode 100644 index 0801ceea637..00000000000 --- a/solr/licenses/hamcrest-core-3.0.jar.sha1 +++ /dev/null @@ -1 +0,0 @@ -254f69f4b0ca22198acfc19fcdd5f96140431c3e diff --git a/solr/modules/analysis-extras/build.gradle b/solr/modules/analysis-extras/build.gradle index 09398b4ac5b..ad1b8714915 100644 --- a/solr/modules/analysis-extras/build.gradle +++ b/solr/modules/analysis-extras/build.gradle @@ -24,25 +24,25 @@ dependencies { implementation project(':solr:solrj') - implementation 'com.ibm.icu:icu4j' - implementation 'org.apache.lucene:lucene-analysis-icu' - runtimeOnly 'org.apache.lucene:lucene-analysis-morfologik' - implementation 'org.apache.lucene:lucene-analysis-opennlp' - runtimeOnly 'org.apache.lucene:lucene-analysis-smartcn' - runtimeOnly 'org.apache.lucene:lucene-analysis-stempel' - implementation 'org.apache.lucene:lucene-core' + implementation libs.ibm.icu.icu4j + implementation libs.apache.lucene.analysis.icu + runtimeOnly libs.apache.lucene.analysis.morfologik + implementation libs.apache.lucene.analysis.opennlp + runtimeOnly libs.apache.lucene.analysis.smartcn + runtimeOnly libs.apache.lucene.analysis.stempel + implementation libs.apache.lucene.core // NOTE: Need to stay on same version of opennlp-tools as lucene-analysis-opennlp - implementation 'org.apache.opennlp:opennlp-tools' - implementation 'org.slf4j:slf4j-api' + implementation libs.apache.opennlp.tools + implementation libs.slf4j.api testImplementation project(':solr:test-framework') - testImplementation 'org.apache.lucene:lucene-analysis-common' - testImplementation 'commons-io:commons-io' - testImplementation 'junit:junit' - testImplementation('org.mockito:mockito-core', { + testImplementation libs.apache.lucene.analysis.common + testImplementation libs.commonsio.commonsio + testImplementation libs.junit.junit + testImplementation(libs.mockito.core, { exclude group: "net.bytebuddy", module: "byte-buddy-agent" }) - testRuntimeOnly('org.mockito:mockito-subclass', { + testRuntimeOnly(libs.mockito.subclass, { exclude group: "net.bytebuddy", module: "byte-buddy-agent" }) } diff --git a/solr/modules/clustering/build.gradle b/solr/modules/clustering/build.gradle index fa0811dda7d..a1546b6b09f 100644 --- a/solr/modules/clustering/build.gradle +++ b/solr/modules/clustering/build.gradle @@ -23,15 +23,15 @@ dependencies { implementation project(':solr:core') implementation project(':solr:solrj') - implementation 'org.apache.lucene:lucene-core' + implementation libs.apache.lucene.core - implementation 'org.carrot2:carrot2-core' - implementation 'org.slf4j:slf4j-api' + implementation libs.carrot2.core + implementation libs.slf4j.api testImplementation project(':solr:test-framework') - testImplementation 'com.carrotsearch.randomizedtesting:randomizedtesting-runner' - testImplementation 'junit:junit' - testImplementation 'org.hamcrest:hamcrest' + testImplementation libs.carrotsearch.randomizedtesting.runner + testImplementation libs.junit.junit + testImplementation libs.hamcrest.hamcrest - testImplementation 'commons-io:commons-io' + testImplementation libs.commonsio.commonsio } diff --git a/solr/modules/cross-dc/build.gradle b/solr/modules/cross-dc/build.gradle index dbd9c00c1bf..459cd46c34a 100644 --- a/solr/modules/cross-dc/build.gradle +++ b/solr/modules/cross-dc/build.gradle @@ -32,22 +32,26 @@ dependencies { implementation project(':solr:solrj') implementation project(':solr:solrj-zookeeper') - implementation 'org.slf4j:slf4j-api' - implementation 'org.apache.kafka:kafka-clients' - implementation 'com.google.guava:guava' - implementation 'io.dropwizard.metrics:metrics-core' - implementation 'org.apache.httpcomponents:httpclient' - implementation 'org.apache.zookeeper:zookeeper' - implementation 'org.apache.zookeeper:zookeeper-jute' + implementation libs.slf4j.api + implementation libs.apache.kafka.clients + implementation libs.google.guava + implementation libs.dropwizard.metrics.core + implementation libs.apache.httpcomponents.httpclient + implementation libs.apache.zookeeper.zookeeper + implementation libs.apache.zookeeper.jute testImplementation project(':solr:test-framework') - testImplementation 'org.apache.lucene:lucene-test-framework' - testImplementation 'junit:junit' - testImplementation 'commons-io:commons-io' - testImplementation 'org.mockito:mockito-core' - testImplementation 'com.carrotsearch.randomizedtesting:randomizedtesting-runner' + testImplementation libs.apache.lucene.testframework + testImplementation libs.junit.junit + testImplementation libs.commonsio.commonsio + testImplementation libs.mockito.core + testImplementation libs.carrotsearch.randomizedtesting.runner - testImplementation "org.apache.kafka:kafka-clients:3.7.1:test" + testImplementation(libs.apache.kafka.clients) { + artifact { + classifier = "test" + } + } } // Make sure that the cloud-minimal.zip artifact is up-to-date with cloud-minimal/conf diff --git a/solr/modules/extraction/build.gradle b/solr/modules/extraction/build.gradle index 952ebee0424..0202cd75910 100644 --- a/solr/modules/extraction/build.gradle +++ b/solr/modules/extraction/build.gradle @@ -23,22 +23,22 @@ dependencies { implementation project(':solr:core') implementation project(':solr:solrj') - implementation 'org.apache.lucene:lucene-core' - implementation 'org.slf4j:slf4j-api' + implementation libs.apache.lucene.core + implementation libs.slf4j.api - implementation 'org.apache.poi:poi' - implementation 'org.apache.poi:poi-ooxml' - implementation 'org.apache.tika:tika-core' - implementation ('org.apache.tika:tika-parsers', { + implementation libs.apache.poi.poi + implementation libs.apache.poi.ooxml + implementation libs.apache.tika.core + implementation (libs.apache.tika.parsers, { exclude group: 'org.apache.cxf', module: 'cxf-rt-rs-client' exclude group: 'org.quartz-scheduler', module: 'quartz' exclude group: 'xml-apis', module: 'xml-apis' }) - implementation ('xerces:xercesImpl', { + implementation (libs.xerces.impl, { exclude group: 'xml-apis', module: 'xml-apis' }) testImplementation project(':solr:test-framework') - testImplementation 'org.apache.lucene:lucene-test-framework' - testImplementation 'junit:junit' + testImplementation libs.apache.lucene.testframework + testImplementation libs.junit.junit } diff --git a/solr/modules/gcs-repository/build.gradle b/solr/modules/gcs-repository/build.gradle index 5eec865fc9d..7a5b9372dc7 100644 --- a/solr/modules/gcs-repository/build.gradle +++ b/solr/modules/gcs-repository/build.gradle @@ -22,23 +22,24 @@ description = 'GCS Backup Repository' dependencies { api project(':solr:core') implementation project(':solr:solrj') - - implementation 'org.apache.lucene:lucene-core' - implementation 'org.slf4j:slf4j-api' - implementation platform(group: 'com.google.cloud', name: 'google-cloud-bom') - implementation 'com.google.api:gax' - implementation 'com.google.auth:google-auth-library-oauth2-http' - implementation 'com.google.auth:google-auth-library-credentials' - implementation 'com.google.cloud:google-cloud-core' - implementation 'com.google.cloud:google-cloud-core-http' - implementation 'com.google.cloud:google-cloud-storage' - implementation 'org.threeten:threetenbp' + implementation libs.apache.lucene.core + implementation libs.slf4j.api + + implementation platform(libs.google.cloud.bom) + implementation platform(libs.grpc.bom) + implementation libs.google.api.gax + implementation libs.google.auth.oauth2http + implementation libs.google.auth.credentials + implementation libs.google.cloud.core + implementation libs.google.cloud.corehttp + implementation libs.google.cloud.storage + implementation libs.threeten.bp testImplementation project(':solr:test-framework') - testImplementation 'org.apache.lucene:lucene-test-framework' - testImplementation 'com.carrotsearch.randomizedtesting:randomizedtesting-runner' - testImplementation 'junit:junit' + testImplementation libs.apache.lucene.testframework + testImplementation libs.carrotsearch.randomizedtesting.runner + testImplementation libs.junit.junit - testImplementation 'com.google.cloud:google-cloud-nio' + testImplementation libs.google.cloud.nio } diff --git a/solr/modules/hadoop-auth/build.gradle b/solr/modules/hadoop-auth/build.gradle index a038264f1f7..ab69cb46907 100644 --- a/solr/modules/hadoop-auth/build.gradle +++ b/solr/modules/hadoop-auth/build.gradle @@ -23,8 +23,8 @@ dependencies { // Spotbugs Annotations are only needed for old findbugs // annotation usage like in Zookeeper during compilation time. // It is not included in the release so exclude from checks. - testCompileOnly 'com.github.spotbugs:spotbugs-annotations' - permitUnusedDeclared 'com.github.spotbugs:spotbugs-annotations' + testCompileOnly libs.spotbugs.annotations + permitUnusedDeclared libs.spotbugs.annotations // Exclude these from jar validation and license checks. configurations.jarValidation { exclude group: "com.github.spotbugs", module: "spotbugs-annotations" @@ -34,61 +34,61 @@ dependencies { implementation project(':solr:solrj') implementation project(':solr:solrj-zookeeper') - implementation 'org.slf4j:slf4j-api' + implementation libs.slf4j.api - api 'org.eclipse.jetty.toolchain:jetty-servlet-api' + api libs.eclipse.jetty.toolchain.servletapi - implementation 'com.fasterxml.jackson.core:jackson-core' - implementation 'com.google.guava:guava' - implementation 'io.dropwizard.metrics:metrics-core' - implementation 'org.apache.httpcomponents:httpclient' - implementation 'org.apache.httpcomponents:httpcore' + implementation libs.fasterxml.jackson.core.core + implementation libs.google.guava + implementation libs.dropwizard.metrics.core + implementation libs.apache.httpcomponents.httpclient + implementation libs.apache.httpcomponents.httpcore - implementation 'org.eclipse.jetty:jetty-client' + implementation libs.eclipse.jetty.client // ZooKeeper & Curator - implementation('org.apache.zookeeper:zookeeper', { + implementation(libs.apache.zookeeper.zookeeper, { exclude group: "org.apache.yetus", module: "audience-annotations" }) // required for instantiating a Zookeeper server (for embedding ZK or running tests) - runtimeOnly 'org.xerial.snappy:snappy-java' + runtimeOnly libs.xerial.snappy.java - implementation('org.apache.curator:curator-framework', { + implementation(libs.apache.curator.framework, { exclude group: 'org.apache.zookeeper', module: 'zookeeper' }) - runtimeOnly('org.apache.curator:curator-recipes', { + runtimeOnly(libs.apache.curator.recipes, { exclude group: 'org.apache.zookeeper', module: 'zookeeper' }) // Hadoop auth framework - implementation 'org.apache.hadoop:hadoop-annotations' - permitUnusedDeclared 'org.apache.hadoop:hadoop-annotations' - implementation ('org.apache.hadoop:hadoop-auth') { transitive = false } - implementation ('org.apache.hadoop:hadoop-common') { transitive = false } + implementation libs.apache.hadoop.annotations + permitUnusedDeclared libs.apache.hadoop.annotations + implementation(libs.apache.hadoop.auth) { transitive = false } + implementation(libs.apache.hadoop.common) { transitive = false } // transitive of hadoop-common; used by Kerberos auth - runtimeOnly 'org.apache.hadoop.thirdparty:hadoop-shaded-guava' - runtimeOnly 'commons-collections:commons-collections' - runtimeOnly 'com.google.re2j:re2j' - runtimeOnly 'org.apache.commons:commons-configuration2' - runtimeOnly 'org.apache.kerby:kerb-core' - runtimeOnly 'org.apache.kerby:kerb-util' + runtimeOnly libs.apache.hadoop.thirdparty.shadedguava + runtimeOnly libs.commonscollections.commonscollections + runtimeOnly libs.google.re2j + runtimeOnly libs.apache.commons.configuration2 + runtimeOnly libs.apache.kerby.core + runtimeOnly libs.apache.kerby.util testImplementation project(':solr:test-framework') - testImplementation 'org.apache.lucene:lucene-test-framework' - testImplementation 'com.carrotsearch.randomizedtesting:randomizedtesting-runner' - testImplementation 'junit:junit' - testImplementation 'org.hamcrest:hamcrest' + testImplementation libs.apache.lucene.testframework + testImplementation libs.carrotsearch.randomizedtesting.runner + testImplementation libs.junit.junit + testImplementation libs.hamcrest.hamcrest - testImplementation('org.mockito:mockito-core', { + testImplementation(libs.mockito.core, { exclude group: "net.bytebuddy", module: "byte-buddy-agent" }) - testRuntimeOnly('org.mockito:mockito-subclass', { + testRuntimeOnly(libs.mockito.subclass, { exclude group: "net.bytebuddy", module: "byte-buddy-agent" }) - testImplementation 'commons-io:commons-io' + testImplementation libs.commonsio.commonsio - testImplementation 'org.apache.lucene:lucene-core' + testImplementation libs.apache.lucene.core testImplementation project(':solr:solrj') @@ -96,7 +96,7 @@ dependencies { testRuntimeOnly project(':solr:modules:analysis-extras') // Hadoop MiniKdc Dependencies (for Kerberos auth tests) - testImplementation ('org.apache.hadoop:hadoop-minikdc', { + testImplementation(libs.apache.hadoop.minikdc, { exclude group:'org.apache.kerby', module:'kerby-xdr' exclude group:'org.apache.kerby', module:'token-provider' exclude group:'org.slf4j', module:'slf4j-reload4j' @@ -105,17 +105,17 @@ dependencies { }) // Zookeeper dependency - some tests like HdfsCloudBackupRestore need this - testImplementation('org.apache.curator:curator-client', { + testImplementation(libs.apache.curator.client, { exclude group: 'org.apache.zookeeper', module: 'zookeeper' }) - testImplementation('org.apache.zookeeper:zookeeper', { + testImplementation(libs.apache.zookeeper.zookeeper, { exclude group: "org.apache.yetus", module: "audience-annotations" }) - testImplementation ('org.apache.zookeeper:zookeeper-jute') { + testImplementation(libs.apache.zookeeper.jute) { exclude group: 'org.apache.yetus', module: 'audience-annotations' } // required for instantiating a Zookeeper server in tests or embedded - testRuntimeOnly ('org.xerial.snappy:snappy-java') + testRuntimeOnly(libs.xerial.snappy.java) } diff --git a/solr/modules/hdfs/build.gradle b/solr/modules/hdfs/build.gradle index 59949458561..b051c9fb1c6 100644 --- a/solr/modules/hdfs/build.gradle +++ b/solr/modules/hdfs/build.gradle @@ -23,52 +23,53 @@ dependencies { implementation project(':solr:core') implementation project(':solr:solrj') - implementation 'org.apache.lucene:lucene-core' + implementation libs.apache.lucene.core - implementation 'org.slf4j:slf4j-api' + implementation libs.slf4j.api - api 'org.apache.hadoop:hadoop-client-api' - runtimeOnly 'org.apache.hadoop:hadoop-client-runtime' + api libs.apache.hadoop.client.api + runtimeOnly libs.apache.hadoop.client.runtime // Guava implements Preconditions, caches, and VisibleForTesting annotations - implementation 'com.google.guava:guava' - implementation 'io.dropwizard.metrics:metrics-core' + implementation libs.google.guava + implementation libs.dropwizard.metrics.core + // Caffeine cache to implement HDFS block caching - implementation 'com.github.ben-manes.caffeine:caffeine' + implementation libs.benmanes.caffeine - implementation 'commons-cli:commons-cli' + implementation libs.commonscli.commonscli testImplementation project(':solr:test-framework') testImplementation project(':solr:solrj-zookeeper') - testImplementation 'org.apache.lucene:lucene-test-framework' - testImplementation 'com.carrotsearch.randomizedtesting:randomizedtesting-runner' - testImplementation 'junit:junit' + testImplementation libs.apache.lucene.testframework + testImplementation libs.carrotsearch.randomizedtesting.runner + testImplementation libs.junit.junit // hadoop dependencies for tests - testImplementation ('org.apache.hadoop:hadoop-hdfs') { transitive = false } - testImplementation ('org.apache.hadoop:hadoop-hdfs::tests') { transitive = false } - testImplementation 'org.apache.hadoop.thirdparty:hadoop-shaded-guava' - testRuntimeOnly 'org.apache.hadoop:hadoop-client-minicluster' + testImplementation(libs.apache.hadoop.hdfs) { transitive = false } + testImplementation(variantOf(libs.apache.hadoop.hdfs) { classifier 'tests' }) { transitive = false } + testImplementation libs.apache.hadoop.thirdparty.shadedguava + testRuntimeOnly libs.apache.hadoop.client.minicluster - testRuntimeOnly 'org.apache.logging.log4j:log4j-1.2-api' + testRuntimeOnly libs.apache.log4j1.api // classes like solr.ICUCollationField, used by NNFailoverTest for example. testRuntimeOnly project(':solr:modules:analysis-extras') // used by the hadoop-specific test framework classes - testImplementation 'commons-io:commons-io' - testImplementation 'org.apache.commons:commons-compress' - testImplementation 'org.apache.commons:commons-collections4' - testImplementation 'org.apache.commons:commons-lang3' - testImplementation 'io.dropwizard.metrics:metrics-core' + testImplementation libs.commonsio.commonsio + testImplementation libs.apache.commons.compress + testImplementation libs.apache.commons.collections4 + testImplementation libs.apache.commons.lang3 + testImplementation libs.dropwizard.metrics.core // Zookeeper dependency - some tests like HdfsCloudBackupRestore need this - permitTestUnusedDeclared 'org.apache.zookeeper:zookeeper' - testImplementation('org.apache.zookeeper:zookeeper', { + permitTestUnusedDeclared libs.apache.zookeeper.zookeeper + testImplementation(libs.apache.zookeeper.zookeeper, { exclude group: "org.apache.yetus", module: "audience-annotations" }) // required for instantiating a Zookeeper server in tests or embedded - testRuntimeOnly 'org.xerial.snappy:snappy-java' + testRuntimeOnly libs.xerial.snappy.java } diff --git a/solr/modules/jwt-auth/build.gradle b/solr/modules/jwt-auth/build.gradle index c2a4990b5b3..6d3f3ac42b0 100644 --- a/solr/modules/jwt-auth/build.gradle +++ b/solr/modules/jwt-auth/build.gradle @@ -28,43 +28,43 @@ configurations { } dependencies { - constraintsOnly(platform("com.fasterxml.jackson:jackson-bom")) + constraintsOnly(platform(libs.fasterxml.jackson.bom)) implementation project(':solr:core') implementation project(':solr:solrj') - implementation 'org.bitbucket.b_c:jose4j' + implementation libs.bc.jose4j - implementation 'io.dropwizard.metrics:metrics-core' - implementation 'org.apache.httpcomponents:httpclient' - implementation 'org.apache.httpcomponents:httpcore' - implementation 'org.eclipse.jetty:jetty-client' - implementation 'org.eclipse.jetty:jetty-http' - implementation 'org.eclipse.jetty.toolchain:jetty-servlet-api' - implementation 'com.google.guava:guava' - implementation 'org.slf4j:slf4j-api' + implementation libs.dropwizard.metrics.core + implementation libs.apache.httpcomponents.httpclient + implementation libs.apache.httpcomponents.httpcore + implementation libs.eclipse.jetty.client + implementation libs.eclipse.jetty.http + implementation libs.eclipse.jetty.toolchain.servletapi + implementation libs.google.guava + implementation libs.slf4j.api testImplementation project(':solr:test-framework') - testImplementation 'org.apache.lucene:lucene-test-framework' - testImplementation 'junit:junit' + testImplementation libs.apache.lucene.testframework + testImplementation libs.junit.junit - testImplementation('org.mockito:mockito-core', { + testImplementation(libs.mockito.core, { exclude group: "net.bytebuddy", module: "byte-buddy-agent" }) - testRuntimeOnly('org.mockito:mockito-subclass', { + testRuntimeOnly(libs.mockito.subclass, { exclude group: "net.bytebuddy", module: "byte-buddy-agent" }) - testImplementation('no.nav.security:mock-oauth2-server', { + testImplementation(libs.navsecurity.mockoauth2server, { exclude group: "io.netty", module: "netty-all" }) // required by mock-oauth2-server - testImplementation 'com.fasterxml.jackson.core:jackson-databind' - permitTestUnusedDeclared 'com.fasterxml.jackson.core:jackson-databind' + testImplementation libs.fasterxml.jackson.core.databind + permitTestUnusedDeclared libs.fasterxml.jackson.core.databind - testImplementation 'org.bouncycastle:bcpkix-jdk18on' - testImplementation 'org.bouncycastle:bcprov-jdk18on' - testImplementation 'com.nimbusds:nimbus-jose-jwt' - testImplementation 'com.squareup.okhttp3:mockwebserver' - testImplementation 'com.squareup.okhttp3:okhttp' - testRuntimeOnly 'io.netty:netty-codec-http' + testImplementation libs.bouncycastle.bcpkix + testImplementation libs.bouncycastle.bcprov + testImplementation libs.nimbusds.josejwt + testImplementation libs.squareup.okhttp3.mockwebserver + testImplementation libs.squareup.okhttp3.okhttp + testRuntimeOnly libs.netty.codechttp } diff --git a/solr/modules/langid/build.gradle b/solr/modules/langid/build.gradle index c25227a7635..dc63a9f9bbc 100644 --- a/solr/modules/langid/build.gradle +++ b/solr/modules/langid/build.gradle @@ -23,14 +23,13 @@ dependencies { implementation project(':solr:core') implementation project(':solr:solrj') - implementation ('org.apache.tika:tika-core') { transitive = false } - implementation 'commons-io:commons-io' - implementation 'com.cybozu.labs:langdetect' - // NOTE: Currently not defined in versions.props since we need to stay on same version as Lucene due to opennlp - implementation 'org.apache.opennlp:opennlp-tools' - implementation 'org.slf4j:slf4j-api' + implementation(libs.apache.tika.core) { transitive = false } + implementation libs.commonsio.commonsio + implementation libs.cybozulabs.langdetect + implementation libs.apache.opennlp.tools + implementation libs.slf4j.api testImplementation project(':solr:test-framework') - testImplementation 'com.carrotsearch.randomizedtesting:randomizedtesting-runner' - testImplementation 'junit:junit' + testImplementation libs.carrotsearch.randomizedtesting.runner + testImplementation libs.junit.junit } diff --git a/solr/modules/ltr/build.gradle b/solr/modules/ltr/build.gradle index 022cf99778b..61e02bb645d 100644 --- a/solr/modules/ltr/build.gradle +++ b/solr/modules/ltr/build.gradle @@ -32,9 +32,9 @@ dependencies { implementation project(':solr:core') implementation project(':solr:solrj') - implementation 'org.apache.lucene:lucene-core' + implementation libs.apache.lucene.core - implementation 'org.slf4j:slf4j-api' + implementation libs.slf4j.api // Used by example scripts generatedPythonClient project(path: ":solr:api", configuration: "pythonClient") @@ -42,20 +42,20 @@ dependencies { builtBy "copyPythonClientToExample" } - testImplementation('org.mockito:mockito-core', { + testImplementation(libs.mockito.core, { exclude group: "net.bytebuddy", module: "byte-buddy-agent" }) - testRuntimeOnly('org.mockito:mockito-subclass', { + testRuntimeOnly(libs.mockito.subclass, { exclude group: "net.bytebuddy", module: "byte-buddy-agent" }) testImplementation project(':solr:test-framework') - testImplementation 'org.apache.lucene:lucene-test-framework' - testImplementation 'com.carrotsearch.randomizedtesting:randomizedtesting-runner' - testImplementation 'junit:junit' - testImplementation 'org.hamcrest:hamcrest' + testImplementation libs.apache.lucene.testframework + testImplementation libs.carrotsearch.randomizedtesting.runner + testImplementation libs.junit.junit + testImplementation libs.hamcrest.hamcrest - testImplementation 'commons-io:commons-io' + testImplementation libs.commonsio.commonsio } task copyPythonClientToExample(type: Sync) { diff --git a/solr/modules/opentelemetry/build.gradle b/solr/modules/opentelemetry/build.gradle index 2c7546af9fe..ee9b3564486 100644 --- a/solr/modules/opentelemetry/build.gradle +++ b/solr/modules/opentelemetry/build.gradle @@ -23,28 +23,29 @@ dependencies { implementation project(':solr:core') implementation project(':solr:solrj') - implementation platform('io.opentelemetry:opentelemetry-bom') - implementation 'org.slf4j:slf4j-api' + implementation platform(libs.netty.bom) + implementation platform(libs.opentelemetry.bom) - implementation platform('io.netty:netty-bom') - implementation 'io.opentelemetry:opentelemetry-api' - implementation 'io.opentelemetry:opentelemetry-sdk-extension-autoconfigure' - runtimeOnly 'io.opentelemetry:opentelemetry-exporter-otlp' + implementation libs.slf4j.api + + implementation libs.opentelemetry.api + implementation libs.opentelemetry.sdkextension.autoconfigure + runtimeOnly libs.opentelemetry.exporter.otlp // End users must recompile with jaeger exporter and/or zipkin exporter if they need these // NOTE: sdk-autoconfigure needs both opentelemetry-sdk-metrics and opentelemetry-sdk-logs even if we don't use them // gRPC transport via netty - since we already ship netty this is more lightweight than netty-shaded - runtimeOnly 'io.grpc:grpc-netty' - runtimeOnly 'io.grpc:grpc-protobuf' - runtimeOnly 'io.grpc:grpc-stub' - runtimeOnly 'io.grpc:grpc-context' + runtimeOnly libs.grpc.netty + runtimeOnly libs.grpc.protobuf + runtimeOnly libs.grpc.stub + runtimeOnly libs.grpc.context // See https://issues.apache.org/jira/browse/LOG4J2-3609 due to needing these annotations - compileOnly 'org.apache.tomcat:annotations-api' + compileOnly libs.apache.tomcat.annotationsapi testImplementation project(':solr:test-framework') - testImplementation 'junit:junit' - testImplementation 'io.opentelemetry:opentelemetry-sdk' - testImplementation 'io.opentelemetry:opentelemetry-sdk-trace' - testImplementation 'io.opentelemetry:opentelemetry-sdk-testing' + testImplementation libs.junit.junit + testImplementation libs.opentelemetry.sdk + testImplementation libs.opentelemetry.sdktrace + testImplementation libs.opentelemetry.sdktesting } diff --git a/solr/modules/s3-repository/build.gradle b/solr/modules/s3-repository/build.gradle index 431df0820a1..15227d57f47 100644 --- a/solr/modules/s3-repository/build.gradle +++ b/solr/modules/s3-repository/build.gradle @@ -23,37 +23,37 @@ dependencies { api project(':solr:core') implementation project(':solr:solrj') - implementation 'org.apache.lucene:lucene-core' - - implementation platform(group: 'software.amazon.awssdk', name: 'bom') - implementation(group: 'software.amazon.awssdk', name: 'auth') - implementation(group: 'software.amazon.awssdk', name: 'apache-client') - implementation(group: 'software.amazon.awssdk', name: 'aws-core') - implementation(group: 'software.amazon.awssdk', name: 'regions') - implementation(group: 'software.amazon.awssdk', name: 'http-client-spi') - implementation(group: 'software.amazon.awssdk', name: 's3') { + implementation libs.apache.lucene.core + + implementation platform(libs.amazon.awssdk.bom) + implementation libs.amazon.awssdk.auth + implementation libs.amazon.awssdk.apacheclient + implementation libs.amazon.awssdk.awscore + implementation libs.amazon.awssdk.regions + implementation libs.amazon.awssdk.httpclient.spi + implementation(libs.amazon.awssdk.s3) { exclude group: 'software.amazon.awssdk', module: 'netty-nio-client' } - implementation(group: 'software.amazon.awssdk', name: 'sdk-core') - runtimeOnly(group: 'software.amazon.awssdk', name: 'sts') { + implementation libs.amazon.awssdk.sdkcore + runtimeOnly(libs.amazon.awssdk.sts) { exclude group: 'software.amazon.awssdk', module: 'netty-nio-client' } - implementation 'com.google.guava:guava' - implementation 'org.slf4j:slf4j-api' + implementation libs.google.guava + implementation libs.slf4j.api - runtimeOnly(group: 'com.fasterxml.woodstox', name: 'woodstox-core') - runtimeOnly(group: 'org.codehaus.woodstox', name: 'stax2-api') + runtimeOnly libs.fasterxml.woodstox.core + runtimeOnly libs.codehaus.woodstox.stax2api testImplementation project(':solr:test-framework') - testImplementation 'org.apache.lucene:lucene-test-framework' - testImplementation 'com.carrotsearch.randomizedtesting:randomizedtesting-runner' - testImplementation 'junit:junit' - testImplementation 'software.amazon.awssdk:profiles' + testImplementation libs.apache.lucene.testframework + testImplementation libs.carrotsearch.randomizedtesting.runner + testImplementation libs.junit.junit + testImplementation libs.amazon.awssdk.profiles - testImplementation 'org.hamcrest:hamcrest' + testImplementation libs.hamcrest.hamcrest - testImplementation('com.adobe.testing:s3mock-junit4') { + testImplementation(libs.adobe.testing.s3mock.junit4) { // Don't pull in separate versions of these libs, just use what Solr already has exclude group: 'org.apache.logging.log4j', module: 'log4j-to-slf4j' exclude group: 'ch.qos.logback', module: 'logback-classic' @@ -65,7 +65,7 @@ dependencies { exclude group: 'software.amazon.awssdk', module: 'netty-nio-client' exclude group: 'org.codehaus.woodstox', module: 'stax2-api' } - testImplementation('com.adobe.testing:s3mock-testsupport-common') { + testImplementation(libs.adobe.testing.s3mock.testsupportcommon) { // Don't pull in separate versions of these libs, just use what Solr already has exclude group: 'org.apache.logging.log4j', module: 'log4j-to-slf4j' exclude group: 'ch.qos.logback', module: 'logback-classic' @@ -78,14 +78,14 @@ dependencies { exclude group: 'org.codehaus.woodstox', module: 'stax2-api' } - testImplementation 'commons-io:commons-io' + testImplementation libs.commonsio.commonsio - testRuntimeOnly 'org.eclipse.jetty:jetty-webapp' + testRuntimeOnly libs.eclipse.jetty.webapp - testImplementation('org.mockito:mockito-core', { + testImplementation(libs.mockito.core, { exclude group: "net.bytebuddy", module: "byte-buddy-agent" }) - testRuntimeOnly('org.mockito:mockito-subclass', { + testRuntimeOnly(libs.mockito.subclass, { exclude group: "net.bytebuddy", module: "byte-buddy-agent" }) } diff --git a/solr/modules/scripting/build.gradle b/solr/modules/scripting/build.gradle index a177f26132a..b035e016e4d 100644 --- a/solr/modules/scripting/build.gradle +++ b/solr/modules/scripting/build.gradle @@ -23,13 +23,13 @@ dependencies { implementation project(':solr:core') implementation project(':solr:solrj') - implementation 'org.apache.lucene:lucene-core' + implementation libs.apache.lucene.core - implementation 'org.slf4j:slf4j-api' - implementation 'commons-io:commons-io' - implementation 'com.google.guava:guava' + implementation libs.slf4j.api + implementation libs.commonsio.commonsio + implementation libs.google.guava testImplementation project(':solr:test-framework') - testImplementation 'org.apache.lucene:lucene-test-framework' - testImplementation 'junit:junit' + testImplementation libs.apache.lucene.testframework + testImplementation libs.junit.junit } diff --git a/solr/modules/sql/build.gradle b/solr/modules/sql/build.gradle index cbaa3fe1312..bdd476b35a2 100644 --- a/solr/modules/sql/build.gradle +++ b/solr/modules/sql/build.gradle @@ -25,11 +25,11 @@ dependencies { implementation project(':solr:solrj-streaming') implementation project(':solr:solrj-zookeeper') - implementation 'org.slf4j:slf4j-api' - implementation 'com.google.guava:guava' + implementation libs.slf4j.api + implementation libs.google.guava // SQL Parser via Calcite - implementation ('org.apache.calcite:calcite-core', { + implementation(libs.apache.calcite.core, { exclude group: 'com.fasterxml.jackson.dataformat', module: 'jackson-dataformat-yaml' exclude group: 'com.google.uzaygezen', module: 'uzaygezen-core' exclude group: 'com.yahoo.datasketches', module: 'sketches-core' @@ -37,15 +37,15 @@ dependencies { exclude group: 'net.minidev', module: 'json-smart' exclude group: 'net.hydromatic', module: 'aggdesigner-algorithm' }) - compileOnly 'org.immutables:value-annotations' // needed due to Calcite requiring this CALCITE-4787 + compileOnly libs.immutables.valueannotations // needed due to Calcite requiring this CALCITE-4787 // sub-deps of calcite-core that we reference directly - implementation 'org.apache.calcite:calcite-linq4j' - implementation 'org.apache.calcite.avatica:avatica-core' - permitUnusedDeclared 'org.apache.calcite.avatica:avatica-core' + implementation libs.apache.calcite.linq4j + implementation libs.apache.calcite.avatica.core + permitUnusedDeclared libs.apache.calcite.avatica.core testImplementation project(':solr:test-framework') - testImplementation 'org.apache.lucene:lucene-test-framework' - testImplementation 'junit:junit' + testImplementation libs.apache.lucene.testframework + testImplementation libs.junit.junit testRuntimeOnly project(':solr:modules:analysis-extras') } diff --git a/solr/packaging/build.gradle b/solr/packaging/build.gradle index f0e17595dcc..913aab3a6c0 100644 --- a/solr/packaging/build.gradle +++ b/solr/packaging/build.gradle @@ -229,9 +229,9 @@ artifacts { task downloadBats(type: NpmTask) { group = 'Build Dependency Download' - args = ["install", "https://github.com/bats-core/bats-core#v1.8.2", - "https://github.com/bats-core/bats-assert#v2.0.0", - "https://github.com/bats-core/bats-file#v0.3.0", + args = ["install", "https://github.com/bats-core/bats-core#v${libs.versions.bats.core.get()}", + "https://github.com/bats-core/bats-assert#v${libs.versions.bats.assert.get()}", + "https://github.com/bats-core/bats-file#v${libs.versions.bats.file.get()}", ] inputs.files("${project.ext.nodeProjectDir}/package.json") diff --git a/solr/prometheus-exporter/build.gradle b/solr/prometheus-exporter/build.gradle index 1f257d5a5ee..b30a5c0a306 100644 --- a/solr/prometheus-exporter/build.gradle +++ b/solr/prometheus-exporter/build.gradle @@ -24,43 +24,43 @@ dependencies { implementation project(':solr:solrj') runtimeOnly project(':solr:solrj-zookeeper') // ideally remove ZK dep - implementation('org.apache.zookeeper:zookeeper', { + implementation(libs.apache.zookeeper.zookeeper, { exclude group: "org.apache.yetus", module: "audience-annotations" }) - implementation ('io.prometheus:simpleclient', { + implementation(libs.prometheus.simpleclient, { exclude group: "io.prometheus", module: "simpleclient_tracer_common" exclude group: "io.prometheus", module: "simpleclient_tracer_otel" exclude group: "io.prometheus", module: "simpleclient_tracer_otel_agent" }) - implementation ('io.prometheus:simpleclient_httpserver', { + implementation(libs.prometheus.simpleclient.httpserver, { exclude group: "io.prometheus", module: "simpleclient_tracer_common" exclude group: "io.prometheus", module: "simpleclient_tracer_otel" exclude group: "io.prometheus", module: "simpleclient_tracer_otel_agent" }) - implementation ('net.thisptr:jackson-jq', { + implementation(libs.thisptr.jacksonjq, { exclude group: "org.jruby.joni", module: "joni" exclude group: "com.fasterxml.jackson.core", module: "jackson-databind" }) - implementation ('com.fasterxml.jackson.core:jackson-databind') - implementation 'commons-cli:commons-cli' - implementation ('com.github.ben-manes.caffeine:caffeine') { transitive = false } - implementation 'org.slf4j:slf4j-api' - implementation 'commons-codec:commons-codec' + implementation libs.fasterxml.jackson.core.databind + implementation libs.commonscli.commonscli + implementation(libs.benmanes.caffeine) { transitive = false } + implementation libs.slf4j.api + implementation libs.commonscodec.commonscodec - runtimeOnly 'org.apache.logging.log4j:log4j-api' - runtimeOnly 'org.apache.logging.log4j:log4j-core' - runtimeOnly 'org.apache.logging.log4j:log4j-slf4j2-impl' - runtimeOnly 'com.lmax:disruptor' + runtimeOnly libs.apache.log4j.api + runtimeOnly libs.apache.log4j.core + runtimeOnly libs.apache.log4j.slf4j2impl + runtimeOnly libs.lmax.disruptor testImplementation project(':solr:test-framework') testImplementation project(':solr:solrj-zookeeper') - testImplementation 'com.carrotsearch.randomizedtesting:randomizedtesting-runner' - testImplementation 'junit:junit' - testImplementation 'org.apache.lucene:lucene-test-framework' + testImplementation libs.carrotsearch.randomizedtesting.runner + testImplementation libs.junit.junit + testImplementation libs.apache.lucene.testframework - testImplementation 'org.apache.httpcomponents:httpclient' - testImplementation 'org.apache.httpcomponents:httpcore' + testImplementation libs.apache.httpcomponents.httpclient + testImplementation libs.apache.httpcomponents.httpcore } ext { diff --git a/solr/server/build.gradle b/solr/server/build.gradle index 93b1196b95b..a7055de6539 100644 --- a/solr/server/build.gradle +++ b/solr/server/build.gradle @@ -37,59 +37,59 @@ configurations { } dependencies { - serverLib('org.eclipse.jetty:jetty-deploy', { + serverLib(libs.eclipse.jetty.deploy, { exclude group: "org.awaitility", module: "awaitility" }) - serverLib 'org.eclipse.jetty:jetty-http' - serverLib 'org.eclipse.jetty:jetty-io' - serverLib 'org.eclipse.jetty:jetty-jmx' - serverLib 'org.eclipse.jetty:jetty-rewrite' - serverLib 'org.eclipse.jetty:jetty-security' - serverLib 'org.eclipse.jetty:jetty-server' - serverLib 'org.eclipse.jetty:jetty-servlet' - serverLib 'org.eclipse.jetty:jetty-servlets' - serverLib 'org.eclipse.jetty:jetty-util' - serverLib 'org.eclipse.jetty:jetty-webapp' - serverLib 'org.eclipse.jetty:jetty-xml' - serverLib 'org.eclipse.jetty:jetty-alpn-server' - serverLib('org.eclipse.jetty:jetty-alpn-java-server', { + serverLib libs.eclipse.jetty.http + serverLib libs.eclipse.jetty.io + serverLib libs.eclipse.jetty.jmx + serverLib libs.eclipse.jetty.rewrite + serverLib libs.eclipse.jetty.security + serverLib libs.eclipse.jetty.server + serverLib libs.eclipse.jetty.servlet + serverLib libs.eclipse.jetty.servlets + serverLib libs.eclipse.jetty.util + serverLib libs.eclipse.jetty.webapp + serverLib libs.eclipse.jetty.xml + serverLib libs.eclipse.jetty.alpnserver + serverLib(libs.eclipse.jetty.alpnjavaserver, { exclude group: "org.eclipse.jetty.alpn", module: "alpn-api" }) - serverLib 'org.eclipse.jetty.http2:http2-server' - serverLib 'org.eclipse.jetty.http2:http2-common' - serverLib 'org.eclipse.jetty.http2:http2-hpack' + serverLib libs.eclipse.jetty.http2.server + serverLib libs.eclipse.jetty.http2.common + serverLib libs.eclipse.jetty.http2.hpack - serverLib 'org.eclipse.jetty.toolchain:jetty-servlet-api' + serverLib libs.eclipse.jetty.toolchain.servletapi - libExt 'com.lmax:disruptor' - libExt 'org.slf4j:jcl-over-slf4j' - libExt 'org.slf4j:jul-to-slf4j' - libExt 'org.slf4j:slf4j-api' - libExt 'org.apache.logging.log4j:log4j-1.2-api' - libExt 'org.apache.logging.log4j:log4j-api' - libExt 'org.apache.logging.log4j:log4j-core' - libExt 'org.apache.logging.log4j:log4j-layout-template-json' - libExt 'org.apache.logging.log4j:log4j-slf4j2-impl' - libExt 'org.apache.logging.log4j:log4j-web' + libExt libs.lmax.disruptor + libExt libs.slf4j.jcloverslf4j + libExt libs.slf4j.jultoslf4j + libExt libs.slf4j.api + libExt libs.apache.log4j1.api + libExt libs.apache.log4j.api + libExt libs.apache.log4j.core + libExt libs.apache.log4j.layout.templatejson + libExt libs.apache.log4j.slf4j2impl + libExt libs.apache.log4j.web - libExt('io.dropwizard.metrics:metrics-core', { + libExt(libs.dropwizard.metrics.core, { exclude group: "com.rabbitmq", module: "amqp-client" }) - libExt('io.dropwizard.metrics:metrics-graphite', { + libExt(libs.dropwizard.metrics.graphite, { exclude group: "com.rabbitmq", module: "amqp-client" }) - libExt('io.dropwizard.metrics:metrics-jetty10', { + libExt(libs.dropwizard.metrics.jetty10, { exclude group: "org.eclipse.jetty", module: "*" exclude group: "org.eclipse.jetty.http2", module: "*" exclude group: "org.eclipse.jetty.toolchain", module: "*" }) - libExt 'io.dropwizard.metrics:metrics-jvm' - libExt 'io.dropwizard.metrics:metrics-jmx' + libExt libs.dropwizard.metrics.jvm + libExt libs.dropwizard.metrics.jmx webapp project(path: ":solr:webapp", configuration: "war") - startJar('org.eclipse.jetty:jetty-start::shaded', { + startJar(variantOf(libs.eclipse.jetty.start) { classifier 'shaded' }, { transitive false }) diff --git a/solr/solr-ref-guide/build.gradle b/solr/solr-ref-guide/build.gradle index 1e455f29849..b548d9981af 100644 --- a/solr/solr-ref-guide/build.gradle +++ b/solr/solr-ref-guide/build.gradle @@ -59,15 +59,6 @@ dependencies { } ext { - antoraVersion = "3.1.4" - antoraLunrExtensionVersion = "1.0.0-alpha.8" - asciidoctorMathjaxVersion = "0.0.9" - asciidoctorTabsVersion = "1.0.0-beta.6" - linkCheckerVersion = "1.4.2" - gulpCliVersion = "2.3.0" - // Most recent commit as of 2022-06-24, this repo does not have tags - antoraDefaultUIVersion = "51ad811622394027afb4e182c2fdabc235ae04dd" - siteDir = "${buildDir}/site" antoraConfigBuildDir = "${buildDir}/antora-config" playbooksDir = "${project.ext.antoraConfigBuildDir}/playbooks" @@ -120,17 +111,17 @@ task buildLocalAntoraYaml { // Set these dependency versions as lazy gstrings so that they're resolved after evaluation. // These variable names must use underscores, not dashes or periods props.putAll([ - ["dep_version_commons_codec", "commons-codec", "commons-codec"], - ["dep_version_dropwizard", "io.dropwizard.metrics", "metrics-core"], - ["dep_version_hadoop", "org.apache.hadoop", "hadoop-auth"], - ["dep_version_log4j", "org.apache.logging.log4j", "log4j-core"], - ["dep_version_opennlp", "org.apache.opennlp", "opennlp-tools"], - ["dep_version_tika", "org.apache.tika", "tika-core"], - ["dep_version_zookeeper", "org.apache.zookeeper", "zookeeper"], - ["dep_version_lucene", "org.apache.lucene", "lucene-core"], - ["dep_version_opentelemetry", "io.opentelemetry", "opentelemetry-sdk"], - ].collectEntries { propKey, depGroup, depId -> - [propKey, "${-> depGroup == 'org.apache.lucene' ? luceneBaseVersionProvider.get() : project.getVersion(depGroup, depId)}"] }) + ["dep_version_commons_codec", libs.versions.commons.codec], + ["dep_version_dropwizard", libs.versions.dropwizard.metrics], + ["dep_version_hadoop", libs.versions.apache.hadoop.asProvider()], + ["dep_version_log4j", libs.versions.apache.log4j], + ["dep_version_opennlp", libs.versions.apache.opennlp], + ["dep_version_tika", libs.versions.apache.tika], + ["dep_version_zookeeper", libs.versions.apache.zookeeper], + ["dep_version_lucene", libs.versions.apache.lucene], + ["dep_version_opentelemetry", libs.versions.opentelemetry], + ].collectEntries { propKey, dependencyVersion -> + [propKey, "${-> dependencyVersion == libs.versions.apache.lucene ? luceneBaseVersionProvider.get() : dependencyVersion.get()}"] }) copy { @@ -217,41 +208,41 @@ dependencies { task downloadAntoraCli(type: NpmTask) { group = 'Build Dependency Download' - args = ["install", "@antora/cli@${project.ext.antoraVersion}"] + args = ["install", "@antora/cli@${libs.versions.antora.asProvider().get()}"] - inputs.property("Antora version", project.ext.antoraVersion) + inputs.property("Antora version", libs.versions.antora.asProvider().get()) outputs.dir("${project.ext.nodeProjectDir}/node_modules/@antora/cli") } task downloadAntoraSiteGenerator(type: NpmTask) { group = 'Build Dependency Download' - args = ["install", "@antora/site-generator-default@${project.ext.antoraVersion}"] + args = ["install", "@antora/site-generator-default@${libs.versions.antora.asProvider().get()}"] - inputs.property("Antora version", project.ext.antoraVersion) + inputs.property("Antora version", libs.versions.antora.asProvider().get()) outputs.dir("${project.ext.nodeProjectDir}/node_modules/@antora/site-generator-default") } task downloadAntoraLunrExtension(type: NpmTask) { group = 'Build Dependency Download' - args = ["install", "@antora/lunr-extension@${project.ext.antoraLunrExtensionVersion}"] + args = ["install", "@antora/lunr-extension@${libs.versions.antora.lunr.extension.get()}"] - inputs.property("Antora lunr-extension version", project.ext.antoraLunrExtensionVersion) + inputs.property("Antora lunr-extension version", libs.versions.antora.lunr.extension.get()) outputs.dir("${project.ext.nodeProjectDir}/node_modules/@antora/lunr-extension") } task downloadAsciidoctorMathjaxExtension(type: NpmTask) { group = 'Build Dependency Download' - args = ["install", "@djencks/asciidoctor-mathjax@${project.ext.asciidoctorMathjaxVersion}"] + args = ["install", "@djencks/asciidoctor-mathjax@${libs.versions.asciidoctor.mathjax.get()}"] - inputs.property("asciidoctor-mathjax version", project.ext.asciidoctorMathjaxVersion) + inputs.property("asciidoctor-mathjax version", libs.versions.asciidoctor.mathjax.get()) outputs.dir("${project.ext.nodeProjectDir}/node_modules/@djencks/asciidoctor-mathjax") } task downloadAsciidoctorTabsExtension(type: NpmTask) { group = 'Build Dependency Download' - args = ["install", "-D", "@asciidoctor/tabs@${project.ext.asciidoctorTabsVersion}"] + args = ["install", "-D", "@asciidoctor/tabs@${libs.versions.asciidoctor.tabs.get()}"] - inputs.property("asciidoctor-tabs version", project.ext.asciidoctorTabsVersion) + inputs.property("asciidoctor-tabs version", libs.versions.asciidoctor.tabs.get()) outputs.dir("${project.ext.nodeProjectDir}/node_modules/@asciidoctor/tabs") } @@ -268,17 +259,17 @@ task downloadAntora { task downloadLinkValidator(type: NpmTask) { group = 'Build Dependency Download' - args = ["install", "link-checker@${project.ext.linkCheckerVersion}"] + args = ["install", "link-checker@${libs.versions.link.checker.get()}"] - inputs.property("link-checker version", project.ext.linkCheckerVersion) + inputs.property("link-checker version", libs.versions.link.checker.get()) outputs.dir("${project.ext.nodeProjectDir}/node_modules/link-checker") } task downloadDefaultUITemplate(type: NpmTask) { group = 'Build Dependency Download' - args = ["install", "gitlab:antora/antora-ui-default#${project.ext.antoraDefaultUIVersion}", "--include=dev"] + args = ["install", "gitlab:antora/antora-ui-default#${libs.versions.antora.default.ui.get()}", "--include=dev"] - inputs.property("Antora default-ui version", project.ext.antoraDefaultUIVersion) + inputs.property("Antora default-ui version", libs.versions.antora.default.ui.get()) outputs.dir("${project.ext.nodeProjectDir}/node_modules/@antora/ui-default") } @@ -316,14 +307,14 @@ task downloadGulp(type: NpmTask) { group = 'Build Dependency Download' dependsOn tasks.startUIBuildDir - args = ["install", "gulp-cli@${project.ext.gulpCliVersion}", "--legacy-peer-deps"] + args = ["install", "gulp-cli@${libs.versions.gulp.cli.get()}", "--legacy-peer-deps"] execOverrides { // The it variable contains the `ExecSpec` workingDir = project.ext.uiBuildDir } - inputs.property("Antora version", project.ext.antoraVersion) - inputs.property("Gulp CLI version", project.ext.gulpCliVersion) + inputs.property("Antora version", libs.versions.antora.asProvider().get()) + inputs.property("Gulp CLI version", libs.versions.gulp.cli.get()) outputs.dir("${project.ext.uiBuildDir}/node_modules/") } @@ -419,7 +410,7 @@ task buildLocalAntoraSite(type: NpxTask) { environment = ["SITE_SEARCH_ENABLED": "true"] inputs.files(fileTree(project.ext.siteStagingDir)) - inputs.property("Antora version", project.ext.antoraVersion) + inputs.property("Antora version", libs.versions.antora.asProvider().get()) outputs.dir(project.ext.siteDir) } @@ -514,7 +505,7 @@ task buildOfficialSite(type: NpxTask) { environment = ["SITE_SEARCH_ENABLED": "true"] inputs.files(officialPlaybook) - inputs.property("Antora version", project.ext.antoraVersion) + inputs.property("Antora version", libs.versions.antora.asProvider().get()) outputs.dir(project.ext.siteDir) doLast { @@ -540,7 +531,7 @@ dependencies { testImplementation project(":solr:core") testImplementation project(":solr:solrj") testImplementation project(":solr:test-framework") - testImplementation 'junit:junit' + testImplementation libs.junit.junit } // Copy all the test resource files from SolrJ to the build/resources/test directory diff --git a/solr/solrj-streaming/build.gradle b/solr/solrj-streaming/build.gradle index 9e4b6b4f3cc..a898ae2bc29 100644 --- a/solr/solrj-streaming/build.gradle +++ b/solr/solrj-streaming/build.gradle @@ -23,26 +23,26 @@ dependencies { implementation project(':solr:solrj') // declare dependencies we use even though already declared by solrj-core - implementation 'org.slf4j:slf4j-api' - implementation 'org.apache.httpcomponents:httpclient' - implementation 'org.apache.httpcomponents:httpcore' - implementation 'org.apache.commons:commons-math3' + implementation libs.slf4j.api + implementation libs.apache.httpcomponents.httpclient + implementation libs.apache.httpcomponents.httpcore + implementation libs.apache.commons.math3 testImplementation project(':solr:test-framework') testImplementation project(':solr:core') testImplementation project(':solr:solrj-zookeeper') testRuntimeOnly project(':solr:modules:sql') - testRuntimeOnly "org.hsqldb:hsqldb" // runtime because via JDBC reflection + testRuntimeOnly libs.hsqldb.hsqldb // runtime because via JDBC reflection - testImplementation 'com.carrotsearch.randomizedtesting:randomizedtesting-runner' - testImplementation 'org.apache.lucene:lucene-test-framework' - testImplementation 'junit:junit' + testImplementation libs.carrotsearch.randomizedtesting.runner + testImplementation libs.apache.lucene.testframework + testImplementation libs.junit.junit - testImplementation('org.apache.zookeeper:zookeeper', { + testImplementation(libs.apache.zookeeper.zookeeper, { exclude group: "org.apache.yetus", module: "audience-annotations" }) - permitTestUnusedDeclared 'org.apache.zookeeper:zookeeper' + permitTestUnusedDeclared libs.apache.zookeeper.zookeeper permitTestUsedUndeclared project(':solr:solrj-streaming') // duh! } diff --git a/solr/solrj-zookeeper/build.gradle b/solr/solrj-zookeeper/build.gradle index 5c63a90e05c..37faa638b3c 100644 --- a/solr/solrj-zookeeper/build.gradle +++ b/solr/solrj-zookeeper/build.gradle @@ -23,8 +23,8 @@ dependencies { // Spotbugs Annotations are only needed for old findbugs // annotation usage like in Zookeeper during compilation time. // It is not included in the release so exclude from checks. - compileOnly 'com.github.spotbugs:spotbugs-annotations' - permitUnusedDeclared 'com.github.spotbugs:spotbugs-annotations' + compileOnly libs.spotbugs.annotations + permitUnusedDeclared libs.spotbugs.annotations // Exclude these from jar validation and license checks. configurations.jarValidation { exclude group: "com.github.spotbugs", module: "spotbugs-annotations" @@ -33,27 +33,27 @@ dependencies { implementation project(':solr:solrj') // declare dependencies we use even though already declared by solrj-core - implementation 'org.slf4j:slf4j-api' + implementation libs.slf4j.api - implementation('org.apache.curator:curator-client', { + implementation(libs.apache.curator.client, { exclude group: 'org.apache.zookeeper', module: 'zookeeper' }) - api('org.apache.curator:curator-framework', { + api(libs.apache.curator.framework, { exclude group: 'org.apache.zookeeper', module: 'zookeeper' }) - api('org.apache.zookeeper:zookeeper', { + api(libs.apache.zookeeper.zookeeper, { exclude group: "org.apache.yetus", module: "audience-annotations" }) - implementation ('org.apache.zookeeper:zookeeper-jute') { + implementation(libs.apache.zookeeper.jute) { exclude group: 'org.apache.yetus', module: 'audience-annotations' } testImplementation project(':solr:test-framework') testImplementation project(':solr:core') - testImplementation 'junit:junit' - testImplementation 'commons-io:commons-io' + testImplementation libs.junit.junit + testImplementation libs.commonsio.commonsio permitTestUsedUndeclared project(':solr:solrj-zookeeper') // duh! } diff --git a/solr/solrj/build.gradle b/solr/solrj/build.gradle index dc1656a4624..2e6636519ff 100644 --- a/solr/solrj/build.gradle +++ b/solr/solrj/build.gradle @@ -16,41 +16,40 @@ */ plugins { - id "org.openapi.generator" version "6.6.0" + alias(libs.plugins.openapi.generator) + alias(libs.plugins.diffplug.spotless) + id 'java-library' } -apply plugin: 'java-library' -apply plugin: 'com.diffplug.spotless' - import com.diffplug.gradle.spotless.JavaExtension description = 'Solrj - Solr Java Client' dependencies { - implementation 'com.fasterxml.jackson.core:jackson-databind' - implementation 'com.fasterxml.jackson.core:jackson-annotations' + implementation libs.fasterxml.jackson.core.databind + implementation libs.fasterxml.jackson.core.annotations api project(":solr:api") - implementation 'org.slf4j:slf4j-api' - runtimeOnly 'org.slf4j:jcl-over-slf4j' + implementation libs.slf4j.api + runtimeOnly libs.slf4j.jcloverslf4j - api 'org.eclipse.jetty.http2:http2-client' - implementation 'org.eclipse.jetty.http2:http2-http-client-transport' - implementation 'org.eclipse.jetty:jetty-http' - implementation 'org.eclipse.jetty:jetty-client' - implementation 'org.eclipse.jetty:jetty-util' - implementation 'org.eclipse.jetty:jetty-io' - runtimeOnly 'org.eclipse.jetty:jetty-alpn-java-client' + api libs.eclipse.jetty.http2.client + implementation libs.eclipse.jetty.http2.httpclienttransport + implementation libs.eclipse.jetty.http + implementation libs.eclipse.jetty.client + implementation libs.eclipse.jetty.util + implementation libs.eclipse.jetty.io + runtimeOnly libs.eclipse.jetty.alpnjavaclient - api('org.apache.httpcomponents:httpmime', { + api(libs.apache.httpcomponents.httpmime, { exclude group: "commons-codec", module: "commons-codec" exclude group: "commons-logging", module: "commons-logging" }) - implementation 'org.apache.httpcomponents:httpclient' - implementation 'org.apache.httpcomponents:httpcore' + implementation libs.apache.httpcomponents.httpclient + implementation libs.apache.httpcomponents.httpcore - compileOnly 'com.github.stephenc.jcip:jcip-annotations' + compileOnly libs.stephenc.jcip.annotations testImplementation project(':solr:test-framework') testImplementation project(':solr:core') @@ -58,42 +57,42 @@ dependencies { // ideally ZK centric tests move to solrj-zookeeper but sometimes we depend on ZK here anyway testImplementation project(':solr:solrj-zookeeper') - testImplementation('org.apache.zookeeper:zookeeper', { + testImplementation(libs.apache.zookeeper.zookeeper, { exclude group: "org.apache.yetus", module: "audience-annotations" }) - permitTestUnusedDeclared 'org.apache.zookeeper:zookeeper' - testImplementation 'org.apache.zookeeper:zookeeper-jute' + permitTestUnusedDeclared libs.apache.zookeeper.zookeeper + testImplementation libs.apache.zookeeper.jute - testImplementation 'org.apache.lucene:lucene-core' - testImplementation 'org.apache.lucene:lucene-test-framework' + testImplementation libs.apache.lucene.core + testImplementation libs.apache.lucene.testframework - testImplementation 'com.carrotsearch.randomizedtesting:randomizedtesting-runner' - testImplementation 'junit:junit' - testImplementation 'org.hamcrest:hamcrest' + testImplementation libs.carrotsearch.randomizedtesting.runner + testImplementation libs.junit.junit + testImplementation libs.hamcrest.hamcrest - testImplementation 'commons-io:commons-io' - testImplementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-cbor' + testImplementation libs.commonsio.commonsio + testImplementation libs.fasterxml.jackson.dataformat.cbor - testImplementation 'org.eclipse.jetty.toolchain:jetty-servlet-api' + testImplementation libs.eclipse.jetty.toolchain.servletapi - testImplementation 'org.eclipse.jetty:jetty-server' - testImplementation 'org.eclipse.jetty:jetty-servlet' - testImplementation 'org.eclipse.jetty:jetty-webapp' - testRuntimeOnly ('org.eclipse.jetty:jetty-alpn-java-server', { + testImplementation libs.eclipse.jetty.server + testImplementation libs.eclipse.jetty.servlet + testImplementation libs.eclipse.jetty.webapp + testRuntimeOnly(libs.eclipse.jetty.alpnjavaserver, { exclude group: "org.eclipse.jetty.alpn", module: "alpn-api" }) - testImplementation('org.mockito:mockito-core', { + testImplementation(libs.mockito.core, { exclude group: "net.bytebuddy", module: "byte-buddy-agent" }) - testRuntimeOnly('org.mockito:mockito-subclass', { + testRuntimeOnly(libs.mockito.subclass, { exclude group: "net.bytebuddy", module: "byte-buddy-agent" }) - testRuntimeOnly("org.apache.logging.log4j:log4j-slf4j2-impl", { + testRuntimeOnly(libs.apache.log4j.slf4j2impl, { exclude group: "org.apache.logging.log4j", module: "log4j-api" }) - testImplementation 'org.apache.commons:commons-lang3' - testImplementation 'io.dropwizard.metrics:metrics-core' - testImplementation 'com.fasterxml.jackson.core:jackson-core' + testImplementation libs.apache.commons.lang3 + testImplementation libs.dropwizard.metrics.core + testImplementation libs.fasterxml.jackson.core.core } /** diff --git a/solr/test-framework/build.gradle b/solr/test-framework/build.gradle index 2207ccbe515..0dfa58b829b 100644 --- a/solr/test-framework/build.gradle +++ b/solr/test-framework/build.gradle @@ -23,8 +23,8 @@ dependencies { // Spotbugs Annotations are only needed for old findbugs // annotation usage like in Zookeeper during compilation time. // It is not included in the release so exclude from checks. - compileOnly 'com.github.spotbugs:spotbugs-annotations' - permitUnusedDeclared 'com.github.spotbugs:spotbugs-annotations' + compileOnly libs.spotbugs.annotations + permitUnusedDeclared libs.spotbugs.annotations // Exclude these from jar validation and license checks. configurations.jarValidation { exclude group: "com.github.spotbugs", module: "spotbugs-annotations" @@ -34,57 +34,57 @@ dependencies { api project(':solr:solrj') implementation project(':solr:solrj-zookeeper') - api 'org.apache.lucene:lucene-test-framework' - implementation 'org.apache.lucene:lucene-core' - implementation 'org.apache.lucene:lucene-queries' - implementation 'org.apache.lucene:lucene-suggest' + api libs.apache.lucene.testframework + implementation libs.apache.lucene.core + implementation libs.apache.lucene.queries + implementation libs.apache.lucene.suggest var zkExcludes = { exclude group: "org.apache.yetus", module: "audience-annotations" } - implementation('org.apache.curator:curator-client', { + implementation(libs.apache.curator.client) { exclude group: 'org.apache.zookeeper', module: 'zookeeper' - }) - implementation('org.apache.curator:curator-framework', { + } + implementation(libs.apache.curator.framework) { exclude group: 'org.apache.zookeeper', module: 'zookeeper' - }) + } // Necessary because ChaosMonkey uses KillSession from curator-test - implementation('org.apache.curator:curator-test') { + implementation(libs.apache.curator.test) { exclude group: 'org.apache.zookeeper', module: 'zookeeper' exclude group: 'com.google.guava', module: 'guava' exclude group: 'io.dropwizard.metrics', module: 'metrics-core' } - implementation('org.apache.zookeeper:zookeeper', zkExcludes) - implementation('org.apache.zookeeper:zookeeper-jute', zkExcludes) - implementation('org.apache.zookeeper:zookeeper::tests', zkExcludes) + implementation(libs.apache.zookeeper.zookeeper, zkExcludes) + implementation(libs.apache.zookeeper.jute, zkExcludes) + implementation(variantOf(libs.apache.zookeeper.zookeeper) { classifier 'tests' }, zkExcludes) - implementation 'commons-io:commons-io' - implementation 'org.slf4j:slf4j-api' - implementation 'org.apache.logging.log4j:log4j-api' - implementation 'org.apache.logging.log4j:log4j-core' - implementation 'io.dropwizard.metrics:metrics-core' - implementation 'io.dropwizard.metrics:metrics-jetty10' - implementation 'commons-cli:commons-cli' - permitUnusedDeclared 'commons-cli:commons-cli' - implementation 'org.apache.httpcomponents:httpclient' - implementation 'org.apache.httpcomponents:httpcore' - implementation 'io.opentelemetry:opentelemetry-api' + implementation libs.commonsio.commonsio + implementation libs.slf4j.api + implementation libs.apache.log4j.api + implementation libs.apache.log4j.core + implementation libs.dropwizard.metrics.core + implementation libs.dropwizard.metrics.jetty10 + implementation libs.commonscli.commonscli + permitUnusedDeclared libs.commonscli.commonscli + implementation libs.apache.httpcomponents.httpclient + implementation libs.apache.httpcomponents.httpcore + implementation libs.opentelemetry.api - implementation 'org.eclipse.jetty.toolchain:jetty-servlet-api' - implementation 'org.eclipse.jetty:jetty-server' - api 'org.eclipse.jetty:jetty-servlet' - implementation 'org.eclipse.jetty:jetty-util' - implementation 'org.eclipse.jetty:jetty-alpn-server' - runtimeOnly('org.eclipse.jetty:jetty-alpn-java-server', { + implementation libs.eclipse.jetty.toolchain.servletapi + implementation libs.eclipse.jetty.server + api libs.eclipse.jetty.servlet + implementation libs.eclipse.jetty.util + implementation libs.eclipse.jetty.alpnserver + runtimeOnly(libs.eclipse.jetty.alpnjavaserver, { exclude group: "org.eclipse.jetty.alpn", module: "alpn-api" }) - implementation 'org.eclipse.jetty:jetty-rewrite' - implementation 'org.eclipse.jetty.http2:http2-server' - implementation 'org.eclipse.jetty.http2:http2-common' + implementation libs.eclipse.jetty.rewrite + implementation libs.eclipse.jetty.http2.server + implementation libs.eclipse.jetty.http2.common - implementation 'com.carrotsearch.randomizedtesting:randomizedtesting-runner' - implementation 'junit:junit' - implementation 'org.hamcrest:hamcrest' + implementation libs.carrotsearch.randomizedtesting.runner + implementation libs.junit.junit + implementation libs.hamcrest.hamcrest } diff --git a/solr/webapp/build.gradle b/solr/webapp/build.gradle index f2b830f544f..f4a27d7a465 100644 --- a/solr/webapp/build.gradle +++ b/solr/webapp/build.gradle @@ -34,7 +34,6 @@ ext { jsClientWorkspace = layout.buildDirectory.dir("jsClientWorkspace").get() jsClientBuildDir = layout.buildDirectory.dir("jsClientBuild").get() jsClientBundleDir = layout.buildDirectory.dir("jsClientBundle").get() - browserifyVersion = "17.0.0" } dependencies { @@ -89,9 +88,9 @@ task jsClientBuild(type: NpmTask) { task downloadBrowserify(type: NpmTask) { group = 'Build Dependency Download' - args = ["install", "browserify@${browserifyVersion}"] + args = ["install", "browserify@${libs.versions.browserify.get()}"] - inputs.property("browserify version", browserifyVersion) + inputs.property("browserify version", libs.versions.browserify.get()) outputs.dir("${nodeProjectDir}/node_modules/browserify") } @@ -105,7 +104,7 @@ task generateJsClientBundle(type: NpxTask) { workingDir = file(jsClientWorkspace) inputs.dir(jsClientWorkspace) - inputs.property("browserify version", browserifyVersion) + inputs.property("browserify version", libs.versions.browserify.get()) outputs.file("${jsClientBuildDir}/index.js") } diff --git a/versions.lock b/versions.lock index 17ce70225e3..b2bec0363ed 100644 --- a/versions.lock +++ b/versions.lock @@ -1,500 +1,20156 @@ -# Run ./gradlew --write-locks to regenerate this file -biz.aQute.bnd:biz.aQute.bnd.annotation:6.4.1 (1 constraints: 0d051636) -com.adobe.xmp:xmpcore:6.1.10 (1 constraints: fd0d5947) -com.beust:jcommander:1.82 (2 constraints: 2b123714) -com.carrotsearch:hppc:0.10.0 (2 constraints: d40fecb0) -com.carrotsearch.randomizedtesting:randomizedtesting-runner:2.8.1 (2 constraints: cf1501e2) -com.cybozu.labs:langdetect:1.1-20120112 (1 constraints: 5c066d5e) -com.epam:parso:2.0.14 (1 constraints: 8e0c750e) -com.fasterxml.jackson:jackson-bom:2.18.0 (13 constraints: 2614e9f5) -com.fasterxml.jackson.core:jackson-annotations:2.18.0 (13 constraints: abfd0034) -com.fasterxml.jackson.core:jackson-core:2.18.0 (16 constraints: 7443a4d1) -com.fasterxml.jackson.core:jackson-databind:2.18.0 (28 constraints: 31054ffd) -com.fasterxml.jackson.dataformat:jackson-dataformat-cbor:2.18.0 (2 constraints: 641ca1f1) -com.fasterxml.jackson.dataformat:jackson-dataformat-csv:2.18.0 (2 constraints: ec19ff7a) -com.fasterxml.jackson.dataformat:jackson-dataformat-smile:2.18.0 (1 constraints: bb0eb266) -com.fasterxml.jackson.datatype:jackson-datatype-jdk8:2.18.0 (5 constraints: aa473255) -com.fasterxml.jackson.module:jackson-module-jakarta-xmlbind-annotations:2.18.0 (2 constraints: ac2419e1) -com.fasterxml.jackson.module:jackson-module-scala_2.13:2.18.0 (2 constraints: ec19ff7a) -com.fasterxml.woodstox:woodstox-core:7.0.0 (2 constraints: 9b23d883) -com.github.ben-manes.caffeine:caffeine:3.1.8 (2 constraints: 1112b117) -com.github.jai-imageio:jai-imageio-core:1.4.0 (1 constraints: 5c0ced01) -com.github.junrar:junrar:7.5.3 (1 constraints: 660c1102) -com.github.luben:zstd-jni:1.5.6-3 (1 constraints: 5f0d6136) -com.github.openjson:openjson:1.0.12 (1 constraints: 8b0c6d0e) -com.github.spotbugs:spotbugs-annotations:4.8.6 (1 constraints: 14051d36) -com.github.stephenc.jcip:jcip-annotations:1.0-1 (3 constraints: c71d2c87) -com.github.virtuald:curvesapi:1.07 (1 constraints: 9e0ac7c0) -com.google.android:annotations:4.1.1.4 (2 constraints: b918820a) -com.google.api:api-common:2.33.0 (5 constraints: 8444f8b5) -com.google.api:gax:2.50.0 (5 constraints: 504a5892) -com.google.api:gax-grpc:2.50.0 (1 constraints: 1b1005a6) -com.google.api:gax-httpjson:2.50.0 (2 constraints: d6201381) -com.google.api-client:google-api-client:2.6.0 (3 constraints: ad32fffc) -com.google.api.grpc:gapic-google-cloud-storage-v2:2.40.1-alpha (2 constraints: e4226438) -com.google.api.grpc:grpc-google-cloud-storage-v2:2.40.1-alpha (2 constraints: e4226438) -com.google.api.grpc:proto-google-cloud-storage-v2:2.40.1-alpha (2 constraints: e4226438) -com.google.api.grpc:proto-google-common-protos:2.41.0 (6 constraints: 184eab81) -com.google.api.grpc:proto-google-iam-v1:1.36.0 (2 constraints: ef1e9acd) -com.google.apis:google-api-services-storage:v1-rev20240621-2.0.0 (2 constraints: da256149) -com.google.auth:google-auth-library-credentials:1.23.0 (7 constraints: cb686112) -com.google.auth:google-auth-library-oauth2-http:1.23.0 (6 constraints: 0f558a85) -com.google.auto.value:auto-value-annotations:1.10.4 (6 constraints: b85aa377) -com.google.cloud:google-cloud-bom:0.224.0 (1 constraints: 6a05a140) -com.google.cloud:google-cloud-core:2.40.0 (3 constraints: 3e2f1a54) -com.google.cloud:google-cloud-core-grpc:2.40.0 (1 constraints: 1a1001a6) -com.google.cloud:google-cloud-core-http:2.40.0 (1 constraints: 1a1001a6) -com.google.cloud:google-cloud-storage:2.40.1 (2 constraints: cf1cc626) -com.google.code.gson:gson:2.11.0 (6 constraints: 0c550bc0) -com.google.errorprone:error_prone_annotations:2.31.0 (15 constraints: a5c51259) -com.google.guava:failureaccess:1.0.2 (2 constraints: fb19bf37) -com.google.guava:guava:33.1.0-jre (27 constraints: 698fe64d) -com.google.guava:listenablefuture:9999.0-empty-to-avoid-conflict-with-guava (2 constraints: 4b35b0a0) -com.google.http-client:google-http-client:1.44.2 (11 constraints: 45bf29b8) -com.google.http-client:google-http-client-apache-v2:1.44.2 (2 constraints: b9201d76) -com.google.http-client:google-http-client-appengine:1.44.2 (2 constraints: de20d781) -com.google.http-client:google-http-client-gson:1.44.2 (7 constraints: 68702d4e) -com.google.http-client:google-http-client-jackson2:1.44.2 (1 constraints: 1f1009a6) -com.google.j2objc:j2objc-annotations:3.0.0 (4 constraints: 453c9e88) -com.google.oauth-client:google-oauth-client:1.36.0 (2 constraints: b720ee75) -com.google.protobuf:protobuf-java:3.25.3 (11 constraints: ed9520ce) -com.google.protobuf:protobuf-java-util:3.25.3 (3 constraints: 3c2b232d) -com.google.re2j:re2j:1.7 (2 constraints: 3914d56f) -com.googlecode.json-simple:json-simple:1.1.1 (2 constraints: 321c78d2) -com.googlecode.juniversalchardet:juniversalchardet:1.0.3 (1 constraints: 5b0ce401) -com.googlecode.plist:dd-plist:1.24 (1 constraints: 300c84f5) -com.healthmarketscience.jackcess:jackcess:4.0.2 (1 constraints: 5d0cf201) -com.healthmarketscience.jackcess:jackcess-encrypt:4.0.1 (1 constraints: 5c0cf101) -com.helger:profiler:1.1.1 (1 constraints: e21053b8) -com.ibm.icu:icu4j:74.2 (1 constraints: ae0f2484) -com.j256.simplemagic:simplemagic:1.17 (1 constraints: dd04f830) -com.jayway.jsonpath:json-path:2.9.0 (2 constraints: 6f12c62c) -com.lmax:disruptor:3.4.4 (1 constraints: 0d050a36) -com.mchange:c3p0:0.9.5.5 (1 constraints: c80c571b) -com.mchange:mchange-commons-java:0.2.19 (1 constraints: 84075b75) -com.pff:java-libpst:0.9.3 (1 constraints: 630cfa01) -com.rometools:rome:1.18.0 (1 constraints: 910c870e) -com.rometools:rome-utils:1.18.0 (1 constraints: 10095d96) -com.squareup.okhttp3:okhttp:4.12.0 (2 constraints: a8264f6a) -com.squareup.okio:okio:3.6.0 (1 constraints: 530c38fd) -com.squareup.okio:okio-jvm:3.6.0 (1 constraints: 500ad3b9) -com.sun.activation:jakarta.activation:1.2.2 (1 constraints: ba0dac35) -com.sun.istack:istack-commons-runtime:3.0.12 (1 constraints: eb0d9a43) -com.tdunning:t-digest:3.3 (1 constraints: aa04232c) -com.thoughtworks.paranamer:paranamer:2.8 (1 constraints: 7c15bdd4) -com.typesafe.scala-logging:scala-logging_2.13:3.9.4 (1 constraints: 070b1fe8) -com.yammer.metrics:metrics-core:2.2.0 (7 constraints: 8760e867) -com.zaxxer:SparseBitSet:1.2 (1 constraints: 0d081e75) -commons-beanutils:commons-beanutils:1.9.4 (1 constraints: be0f0384) -commons-cli:commons-cli:1.9.0 (2 constraints: a90fcab3) -commons-codec:commons-codec:1.17.1 (11 constraints: 5a953ac4) -commons-collections:commons-collections:3.2.2 (3 constraints: 77242dac) -commons-digester:commons-digester:2.1 (1 constraints: 550fb664) -commons-io:commons-io:2.15.1 (10 constraints: ff7571ba) -commons-validator:commons-validator:1.7 (1 constraints: a10a3dd2) -de.l3s.boilerpipe:boilerpipe:1.1.0 (1 constraints: 590ce401) -edu.ucar:cdm:4.5.5 (3 constraints: 9d1abd7d) -edu.ucar:grib:4.5.5 (1 constraints: 650c0402) -edu.ucar:httpservices:4.5.5 (2 constraints: 8f122834) -edu.ucar:netcdf4:4.5.5 (1 constraints: 650c0402) -edu.ucar:udunits:4.5.5 (1 constraints: 2b06034e) -edu.usc.ir:sentiment-analysis-parser:0.1 (1 constraints: fa0b50e9) -io.dropwizard.metrics:metrics-annotation:4.2.26 (1 constraints: 361073b0) -io.dropwizard.metrics:metrics-core:4.2.26 (10 constraints: b190d0d8) -io.dropwizard.metrics:metrics-graphite:4.2.26 (1 constraints: 4005473b) -io.dropwizard.metrics:metrics-healthchecks:4.2.26 (1 constraints: 1d1183c9) -io.dropwizard.metrics:metrics-jetty10:4.2.26 (1 constraints: 4005473b) -io.dropwizard.metrics:metrics-jmx:4.2.26 (1 constraints: 4005473b) -io.dropwizard.metrics:metrics-json:4.2.26 (1 constraints: 1d1183c9) -io.dropwizard.metrics:metrics-jvm:4.2.26 (2 constraints: 5c16b800) -io.dropwizard.metrics:metrics-servlets:4.2.26 (1 constraints: 4005473b) -io.grpc:grpc-alts:1.65.1 (1 constraints: 1f100ba6) -io.grpc:grpc-api:1.65.1 (8 constraints: 6951e68b) -io.grpc:grpc-auth:1.65.1 (1 constraints: 1f100ba6) -io.grpc:grpc-context:1.65.1 (6 constraints: 8f445188) -io.grpc:grpc-core:1.65.1 (3 constraints: 4321151f) -io.grpc:grpc-googleapis:1.65.1 (1 constraints: 1f100ba6) -io.grpc:grpc-grpclb:1.65.1 (1 constraints: 1f100ba6) -io.grpc:grpc-inprocess:1.65.1 (1 constraints: 1f100ba6) -io.grpc:grpc-netty:1.65.1 (1 constraints: 3f054d3b) -io.grpc:grpc-netty-shaded:1.65.1 (1 constraints: 1f100ba6) -io.grpc:grpc-protobuf:1.65.1 (2 constraints: 5d15c9d7) -io.grpc:grpc-protobuf-lite:1.65.1 (2 constraints: 291aca4d) -io.grpc:grpc-rls:1.65.1 (1 constraints: 1f100ba6) -io.grpc:grpc-services:1.65.1 (1 constraints: 1f100ba6) -io.grpc:grpc-stub:1.65.1 (2 constraints: 5d15c9d7) -io.grpc:grpc-util:1.65.1 (2 constraints: ec1876f9) -io.grpc:grpc-xds:1.65.1 (1 constraints: 1f100ba6) -io.netty:netty-bom:4.1.114.Final (1 constraints: 8507c567) -io.netty:netty-buffer:4.1.114.Final (11 constraints: 73a6ad35) -io.netty:netty-codec:4.1.114.Final (6 constraints: 5a5150a9) -io.netty:netty-codec-http:4.1.114.Final (4 constraints: fa2f72f8) -io.netty:netty-codec-http2:4.1.114.Final (2 constraints: 3c16cf31) -io.netty:netty-codec-socks:4.1.114.Final (2 constraints: 6a1a3f4b) -io.netty:netty-common:4.1.114.Final (13 constraints: 3dc0e6cd) -io.netty:netty-handler:4.1.114.Final (4 constraints: 1637bb40) -io.netty:netty-handler-proxy:4.1.114.Final (2 constraints: 3c16cf31) -io.netty:netty-resolver:4.1.114.Final (3 constraints: d7254fb5) -io.netty:netty-tcnative-boringssl-static:2.0.66.Final (2 constraints: d11a4158) -io.netty:netty-tcnative-classes:2.0.66.Final (2 constraints: d61e8b95) -io.netty:netty-transport:4.1.114.Final (10 constraints: 97988ae2) -io.netty:netty-transport-classes-epoll:4.1.114.Final (2 constraints: 071ebe65) -io.netty:netty-transport-native-epoll:4.1.114.Final (2 constraints: 301bc584) -io.netty:netty-transport-native-unix-common:4.1.114.Final (5 constraints: 2249871c) -io.opencensus:opencensus-api:0.31.1 (5 constraints: 924d4692) -io.opencensus:opencensus-contrib-http-util:0.31.1 (3 constraints: 7232a9fc) -io.opencensus:opencensus-proto:0.2.0 (1 constraints: e60fd595) -io.opentelemetry:opentelemetry-api:1.40.0 (9 constraints: 36a23843) -io.opentelemetry:opentelemetry-api-incubator:1.40.0-alpha (5 constraints: b670fcef) -io.opentelemetry:opentelemetry-bom:1.40.0 (1 constraints: 3705353b) -io.opentelemetry:opentelemetry-context:1.40.0 (2 constraints: 1f1f08b4) -io.opentelemetry:opentelemetry-exporter-common:1.40.0 (3 constraints: 413dfba8) -io.opentelemetry:opentelemetry-exporter-otlp:1.40.0 (1 constraints: 920fe683) -io.opentelemetry:opentelemetry-exporter-otlp-common:1.40.0 (2 constraints: 4a234b1b) -io.opentelemetry:opentelemetry-exporter-sender-okhttp:1.40.0 (2 constraints: 4a234b1b) -io.opentelemetry:opentelemetry-sdk:1.40.0 (4 constraints: 5956d8bc) -io.opentelemetry:opentelemetry-sdk-common:1.40.0 (6 constraints: 696c1b59) -io.opentelemetry:opentelemetry-sdk-extension-autoconfigure:1.40.0 (1 constraints: 920fe683) -io.opentelemetry:opentelemetry-sdk-extension-autoconfigure-spi:1.40.0 (4 constraints: 13518fcb) -io.opentelemetry:opentelemetry-sdk-logs:1.40.0 (3 constraints: df325ab0) -io.opentelemetry:opentelemetry-sdk-metrics:1.40.0 (3 constraints: df325ab0) -io.opentelemetry:opentelemetry-sdk-trace:1.40.0 (3 constraints: df325ab0) -io.perfmark:perfmark-api:0.27.0 (3 constraints: 22216516) -io.prometheus:prometheus-metrics-exposition-formats:1.1.0 (1 constraints: 0405f335) -io.prometheus:prometheus-metrics-model:1.1.0 (2 constraints: 411b133b) -io.prometheus:simpleclient:0.16.0 (3 constraints: 9d257513) -io.prometheus:simpleclient_common:0.16.0 (1 constraints: 1a1139c0) -io.prometheus:simpleclient_httpserver:0.16.0 (1 constraints: 3905353b) -io.sgr:s2-geometry-library-java:1.0.0 (1 constraints: b0107fb9) -io.swagger.core.v3:swagger-annotations-jakarta:2.2.22 (1 constraints: 3a05373b) -jakarta.activation:jakarta.activation-api:1.2.2 (1 constraints: 8e0f4791) -jakarta.annotation:jakarta.annotation-api:2.1.1 (4 constraints: c94095a4) -jakarta.inject:jakarta.inject-api:2.0.1 (5 constraints: 1d49b79e) -jakarta.validation:jakarta.validation-api:3.0.2 (1 constraints: fe10bbc3) -jakarta.ws.rs:jakarta.ws.rs-api:3.1.0 (6 constraints: 7365f954) -jakarta.xml.bind:jakarta.xml.bind-api:2.3.3 (3 constraints: 882a5cbd) -javax.measure:unit-api:1.0 (5 constraints: 8e3e2cc5) -joda-time:joda-time:2.8.1 (3 constraints: d61aef93) -junit:junit:4.13.2 (7 constraints: 136d2cb8) -net.arnx:jsonic:1.2.7 (1 constraints: d00b47eb) -net.java.dev.jna:jna:5.12.1 (1 constraints: 900c8e0e) -net.sf.ehcache:ehcache-core:2.6.2 (1 constraints: 2706f94d) -net.sf.jopt-simple:jopt-simple:5.0.4 (3 constraints: 132590bf) -net.sourceforge.argparse4j:argparse4j:0.7.0 (1 constraints: fe0a06e8) -net.thisptr:jackson-jq:0.0.13 (1 constraints: 3605223b) -org.antlr:antlr4-runtime:4.11.1 (1 constraints: f70fbd96) -org.apache.calcite:calcite-core:1.37.0 (1 constraints: 3d05463b) -org.apache.calcite:calcite-linq4j:1.37.0 (2 constraints: cf12444c) -org.apache.calcite.avatica:avatica-core:1.25.0 (3 constraints: 0121ddcc) -org.apache.calcite.avatica:avatica-metrics:1.25.0 (1 constraints: 9b104fc4) -org.apache.commons:commons-collections4:4.4 (3 constraints: 2a172a57) -org.apache.commons:commons-compress:1.26.1 (3 constraints: 011cf2d2) -org.apache.commons:commons-configuration2:2.11.0 (1 constraints: 3605323b) -org.apache.commons:commons-csv:1.9.0 (1 constraints: 610cfc01) -org.apache.commons:commons-exec:1.4.0 (2 constraints: 031132cf) -org.apache.commons:commons-lang3:3.15.0 (6 constraints: cc4e807b) -org.apache.commons:commons-math3:3.6.1 (5 constraints: 57322799) -org.apache.commons:commons-text:1.12.0 (2 constraints: 651f97e5) -org.apache.curator:curator-client:5.7.1 (2 constraints: ee14fda3) -org.apache.curator:curator-framework:5.7.1 (2 constraints: 0b14da75) -org.apache.curator:curator-recipes:5.7.1 (1 constraints: 0f051a36) -org.apache.curator:curator-test:5.7.1 (1 constraints: 0f051a36) -org.apache.hadoop:hadoop-annotations:3.4.0 (1 constraints: 09050636) -org.apache.hadoop:hadoop-auth:3.4.0 (1 constraints: 09050636) -org.apache.hadoop:hadoop-client-api:3.4.0 (3 constraints: 16281b5e) -org.apache.hadoop:hadoop-client-runtime:3.4.0 (2 constraints: 6517d242) -org.apache.hadoop:hadoop-common:3.4.0 (1 constraints: 09050636) -org.apache.hadoop.thirdparty:hadoop-shaded-guava:1.2.0 (1 constraints: 0505f635) -org.apache.httpcomponents:httpclient:4.5.14 (9 constraints: 62806342) -org.apache.httpcomponents:httpcore:4.4.16 (8 constraints: 256d4617) -org.apache.httpcomponents:httpmime:4.5.14 (3 constraints: eb1bfedc) -org.apache.httpcomponents.client5:httpclient5:5.2.1 (1 constraints: 6b10bdb3) -org.apache.httpcomponents.core5:httpcore5:5.2.3 (3 constraints: 40351d23) -org.apache.httpcomponents.core5:httpcore5-h2:5.2 (1 constraints: dd12c315) -org.apache.james:apache-mime4j-core:0.8.4 (2 constraints: 981a0d67) -org.apache.james:apache-mime4j-dom:0.8.4 (1 constraints: 630cf801) -org.apache.kafka:kafka-clients:3.7.1 (11 constraints: 298cedc0) -org.apache.kafka:kafka-group-coordinator:3.7.1 (1 constraints: 020b16e8) -org.apache.kafka:kafka-metadata:3.7.1 (2 constraints: 0b1cc414) -org.apache.kafka:kafka-raft:3.7.1 (2 constraints: 4e1837f1) -org.apache.kafka:kafka-server:3.7.1 (1 constraints: 020b16e8) -org.apache.kafka:kafka-server-common:3.7.1 (8 constraints: 2462787a) -org.apache.kafka:kafka-storage:3.7.1 (1 constraints: 020b16e8) -org.apache.kafka:kafka-storage-api:3.7.1 (2 constraints: 0218d3d8) -org.apache.kafka:kafka-streams:3.7.1 (1 constraints: 0d051036) -org.apache.kafka:kafka-tools-api:3.7.1 (1 constraints: 020b16e8) -org.apache.kafka:kafka_2.13:3.7.1 (1 constraints: 0d051036) -org.apache.kerby:kerb-core:2.0.3 (5 constraints: 743627e0) -org.apache.kerby:kerb-crypto:2.0.3 (2 constraints: dc177597) -org.apache.kerby:kerb-util:2.0.3 (3 constraints: 201d584d) -org.apache.kerby:kerby-asn1:2.0.3 (1 constraints: 000cf0f4) -org.apache.kerby:kerby-config:2.0.3 (4 constraints: 593132bc) -org.apache.kerby:kerby-pkix:2.0.3 (1 constraints: 740b03e5) -org.apache.kerby:kerby-util:2.0.3 (2 constraints: 6b1837b7) -org.apache.logging.log4j:log4j-1.2-api:2.21.0 (1 constraints: 3705363b) -org.apache.logging.log4j:log4j-api:2.21.0 (9 constraints: 976ff7be) -org.apache.logging.log4j:log4j-core:2.21.0 (5 constraints: 5f510091) -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.11.1 (10 constraints: aaa06d27) -org.apache.lucene:lucene-analysis-icu:9.11.1 (1 constraints: 3e055d3b) -org.apache.lucene:lucene-analysis-kuromoji:9.11.1 (1 constraints: 3e055d3b) -org.apache.lucene:lucene-analysis-morfologik:9.11.1 (1 constraints: 3e055d3b) -org.apache.lucene:lucene-analysis-nori:9.11.1 (1 constraints: 3e055d3b) -org.apache.lucene:lucene-analysis-opennlp:9.11.1 (1 constraints: 3e055d3b) -org.apache.lucene:lucene-analysis-phonetic:9.11.1 (1 constraints: 3e055d3b) -org.apache.lucene:lucene-analysis-smartcn:9.11.1 (1 constraints: 3e055d3b) -org.apache.lucene:lucene-analysis-stempel:9.11.1 (1 constraints: 3e055d3b) -org.apache.lucene:lucene-backward-codecs:9.11.1 (1 constraints: 3e055d3b) -org.apache.lucene:lucene-classification:9.11.1 (1 constraints: 3e055d3b) -org.apache.lucene:lucene-codecs:9.11.1 (3 constraints: 2c26e99d) -org.apache.lucene:lucene-core:9.11.1 (26 constraints: c194eb01) -org.apache.lucene:lucene-expressions:9.11.1 (1 constraints: 3e055d3b) -org.apache.lucene:lucene-grouping:9.11.1 (2 constraints: 42164308) -org.apache.lucene:lucene-highlighter:9.11.1 (1 constraints: 3e055d3b) -org.apache.lucene:lucene-join:9.11.1 (1 constraints: 3e055d3b) -org.apache.lucene:lucene-memory:9.11.1 (1 constraints: c80f6e93) -org.apache.lucene:lucene-misc:9.11.1 (1 constraints: 3e055d3b) -org.apache.lucene:lucene-queries:9.11.1 (6 constraints: ce52d7fa) -org.apache.lucene:lucene-queryparser:9.11.1 (1 constraints: 3e055d3b) -org.apache.lucene:lucene-sandbox:9.11.1 (1 constraints: fc0f1b97) -org.apache.lucene:lucene-spatial-extras:9.11.1 (1 constraints: 3e055d3b) -org.apache.lucene:lucene-spatial3d:9.11.1 (1 constraints: eb1099ca) -org.apache.lucene:lucene-suggest:9.11.1 (1 constraints: 3e055d3b) -org.apache.lucene:lucene-test-framework:9.11.1 (1 constraints: 3e055d3b) -org.apache.opennlp:opennlp-tools:1.9.4 (2 constraints: fc1dce6d) -org.apache.pdfbox:fontbox:2.0.26 (1 constraints: 180b72d8) -org.apache.pdfbox:jbig2-imageio:3.0.4 (1 constraints: 5e0cef01) -org.apache.pdfbox:jempbox:1.8.16 (1 constraints: 970c910e) -org.apache.pdfbox:pdfbox:2.0.26 (2 constraints: ea1857e7) -org.apache.pdfbox:pdfbox-tools:2.0.26 (1 constraints: 910c790e) -org.apache.pdfbox:preflight:2.0.26 (1 constraints: 910c790e) -org.apache.pdfbox:xmpbox:2.0.26 (2 constraints: ea1857e7) -org.apache.poi:poi:5.2.2 (3 constraints: e623e7de) -org.apache.poi:poi-ooxml:5.2.2 (1 constraints: 600cfd01) -org.apache.poi:poi-ooxml-lite:5.2.2 (1 constraints: cd0a9fcb) -org.apache.poi:poi-scratchpad:5.2.2 (1 constraints: 600cfd01) -org.apache.sis.core:sis-feature:1.2 (1 constraints: 600e0c44) -org.apache.sis.core:sis-metadata:1.2 (5 constraints: e9435488) -org.apache.sis.core:sis-referencing:1.2 (3 constraints: 4829fae1) -org.apache.sis.core:sis-utility:1.2 (4 constraints: 0b35ce5b) -org.apache.sis.storage:sis-netcdf:1.2 (1 constraints: fc0b54e9) -org.apache.sis.storage:sis-storage:1.2 (1 constraints: df0de432) -org.apache.tika:tika-core:1.28.5 (2 constraints: d8118f11) -org.apache.tika:tika-parsers:1.28.5 (1 constraints: 42054a3b) -org.apache.tomcat:annotations-api:6.0.53 (1 constraints: 40054e3b) -org.apache.xmlbeans:xmlbeans:5.0.3 (2 constraints: 72173075) -org.apache.zookeeper:zookeeper:3.9.2 (2 constraints: 15105ed4) -org.apache.zookeeper:zookeeper-jute:3.9.2 (2 constraints: 9d12b123) -org.apiguardian:apiguardian-api:1.1.2 (4 constraints: b03c1624) -org.bitbucket.b_c:jose4j:0.9.6 (2 constraints: 14106bd4) -org.bouncycastle:bcmail-jdk15on:1.70 (1 constraints: 310c8af5) -org.bouncycastle:bcpkix-jdk15on:1.70 (2 constraints: ce1b11b3) -org.bouncycastle:bcprov-jdk15on:1.70 (4 constraints: 1f34ee12) -org.bouncycastle:bcutil-jdk15on:1.70 (2 constraints: 961ad454) -org.brotli:dec:0.1.2 (1 constraints: 5a0ce101) -org.carrot2:carrot2-core:4.5.1 (1 constraints: 0c050f36) -org.carrot2:morfologik-fsa:2.1.9 (1 constraints: db0d9c36) -org.carrot2:morfologik-polish:2.1.9 (1 constraints: d312541e) -org.carrot2:morfologik-stemming:2.1.9 (2 constraints: d81fb300) -org.ccil.cowan.tagsoup:tagsoup:1.2.1 (1 constraints: 5b0ce801) -org.checkerframework:checker-qual:3.44.0 (5 constraints: 6c46e5ef) -org.codehaus.janino:commons-compiler:3.1.11 (2 constraints: 83195319) -org.codehaus.janino:janino:3.1.11 (1 constraints: 8e0d433a) -org.codehaus.woodstox:stax2-api:4.2.2 (2 constraints: 38155daf) -org.codelibs:jhighlight:1.1.0 (1 constraints: 590ce401) -org.conscrypt:conscrypt-openjdk-uber:2.5.2 (1 constraints: ed0fea95) -org.eclipse.jetty:jetty-alpn-client:10.0.22 (3 constraints: eb2e095f) -org.eclipse.jetty:jetty-alpn-java-client:10.0.22 (2 constraints: 1b1b156e) -org.eclipse.jetty:jetty-alpn-java-server:10.0.22 (1 constraints: 67059040) -org.eclipse.jetty:jetty-alpn-server:10.0.22 (2 constraints: f116a748) -org.eclipse.jetty:jetty-client:10.0.22 (2 constraints: 1b1b156e) -org.eclipse.jetty:jetty-deploy:10.0.22 (1 constraints: 67059040) -org.eclipse.jetty:jetty-http:10.0.22 (6 constraints: 694ff186) -org.eclipse.jetty:jetty-io:10.0.22 (9 constraints: a27dfdd5) -org.eclipse.jetty:jetty-jmx:10.0.22 (1 constraints: 67059040) -org.eclipse.jetty:jetty-rewrite:10.0.22 (1 constraints: 67059040) -org.eclipse.jetty:jetty-security:10.0.22 (2 constraints: b813c578) -org.eclipse.jetty:jetty-server:10.0.22 (7 constraints: d16d9a19) -org.eclipse.jetty:jetty-servlet:10.0.22 (2 constraints: 3213f360) -org.eclipse.jetty:jetty-servlets:10.0.22 (1 constraints: 67059040) -org.eclipse.jetty:jetty-util:10.0.22 (9 constraints: a081b682) -org.eclipse.jetty:jetty-webapp:10.0.22 (2 constraints: 40137b61) -org.eclipse.jetty:jetty-xml:10.0.22 (3 constraints: 0b21bdb9) -org.eclipse.jetty.http2:http2-client:10.0.22 (2 constraints: 1b1b156e) -org.eclipse.jetty.http2:http2-common:10.0.22 (3 constraints: d924c560) -org.eclipse.jetty.http2:http2-hpack:10.0.22 (2 constraints: 1e1508e0) -org.eclipse.jetty.http2:http2-http-client-transport:10.0.22 (1 constraints: 67059040) -org.eclipse.jetty.http2:http2-server:10.0.22 (1 constraints: 67059040) -org.eclipse.jetty.toolchain:jetty-servlet-api:4.0.6 (4 constraints: 883053bf) -org.gagravarr:vorbis-java-core:0.8 (1 constraints: 010c57e9) -org.gagravarr:vorbis-java-tika:0.8 (1 constraints: 010c57e9) -org.glassfish.hk2:hk2-api:3.1.1 (2 constraints: 70114901) -org.glassfish.hk2:hk2-locator:3.1.1 (1 constraints: 4410d8ad) -org.glassfish.hk2:hk2-utils:3.1.1 (2 constraints: 19178676) -org.glassfish.hk2:osgi-resource-locator:1.0.3 (1 constraints: ef10e7c2) -org.glassfish.hk2.external:aopalliance-repackaged:3.1.1 (2 constraints: 19178676) -org.glassfish.jaxb:jaxb-runtime:2.3.8 (2 constraints: 23175d5b) -org.glassfish.jaxb:txw2:2.3.8 (1 constraints: c20dba35) -org.glassfish.jersey.containers:jersey-container-jetty-http:2.39.1 (1 constraints: 4105533b) -org.glassfish.jersey.core:jersey-client:3.1.9 (1 constraints: 0611c5c3) -org.glassfish.jersey.core:jersey-common:3.1.9 (6 constraints: 4466dccc) -org.glassfish.jersey.core:jersey-server:3.1.9 (2 constraints: 491efe41) -org.glassfish.jersey.ext:jersey-entity-filtering:3.1.9 (1 constraints: c3152bd3) -org.glassfish.jersey.inject:jersey-hk2:3.1.9 (1 constraints: 0f050636) -org.glassfish.jersey.media:jersey-media-json-jackson:3.1.9 (1 constraints: 0f050636) -org.hamcrest:hamcrest:3.0 (3 constraints: 74208125) -org.hamcrest:hamcrest-core:3.0 (1 constraints: cc05fe3f) -org.immutables:value-annotations:2.10.1 (1 constraints: 3605303b) -org.itadaki:bzip2:0.9.1 (2 constraints: bd0c4b2c) -org.javassist:javassist:3.30.2-GA (1 constraints: 2811fff0) -org.jctools:jctools-core:4.0.5 (1 constraints: 0b050436) -org.jdom:jdom2:2.0.6.1 (1 constraints: be0c371b) -org.jetbrains:annotations:13.0 (1 constraints: df0e795c) -org.jetbrains.kotlin:kotlin-stdlib:1.9.10 (4 constraints: 5c405537) -org.jetbrains.kotlin:kotlin-stdlib-common:1.9.10 (3 constraints: 3a2c8a72) -org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.9.10 (1 constraints: e210ffd2) -org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.9.10 (4 constraints: e23809e7) -org.junit:junit-bom:5.6.2 (2 constraints: 67212a70) -org.junit.jupiter:junit-jupiter-api:5.6.2 (2 constraints: e516c64d) -org.junit.platform:junit-platform-commons:1.6.2 (2 constraints: 7c1841a1) -org.locationtech.jts:jts-core:1.19.0 (2 constraints: a31de760) -org.locationtech.jts.io:jts-io-common:1.19.0 (1 constraints: 930d513a) -org.locationtech.proj4j:proj4j:1.2.2 (1 constraints: 5d0daf2c) -org.locationtech.spatial4j:spatial4j:0.8 (1 constraints: 59105498) -org.lz4:lz4-java:1.8.0 (1 constraints: fc0cd91b) -org.opengis:geoapi:3.0.1 (7 constraints: 1361d046) -org.openjdk.jmh:jmh-core:1.37 (1 constraints: df04fc30) -org.opentest4j:opentest4j:1.2.0 (1 constraints: 670f0e7d) -org.osgi:org.osgi.resource:1.0.0 (1 constraints: e60f2999) -org.osgi:org.osgi.service.serviceloader:1.0.0 (1 constraints: e60f2999) -org.osgi:osgi.annotation:8.1.0 (1 constraints: 0b051636) -org.ow2.asm:asm:9.3 (5 constraints: e339cef2) -org.ow2.asm:asm-analysis:7.2 (1 constraints: e409d9a5) -org.ow2.asm:asm-commons:7.2 (1 constraints: 6b0f7267) -org.ow2.asm:asm-tree:7.2 (2 constraints: 2f14468c) -org.pcollections:pcollections:4.0.1 (1 constraints: 530f2e7d) -org.quicktheories:quicktheories:0.26 (1 constraints: dc04f530) -org.reactivestreams:reactive-streams:1.0.4 (4 constraints: 073bf033) -org.rocksdb:rocksdbjni:7.9.2 (1 constraints: 120d091d) -org.scala-lang:scala-library:2.13.15 (6 constraints: c4673aa1) -org.scala-lang:scala-reflect:2.13.12 (2 constraints: bb1d08f4) -org.scala-lang.modules:scala-collection-compat_2.13:2.10.0 (1 constraints: 2a0b2af3) -org.scala-lang.modules:scala-java8-compat_2.13:1.0.2 (1 constraints: fa0af8e7) -org.semver4j:semver4j:5.3.0 (1 constraints: 0a050d36) -org.slf4j:jcl-over-slf4j:2.0.13 (3 constraints: fa17e8b5) -org.slf4j:jul-to-slf4j:2.0.13 (3 constraints: 54285f5f) -org.slf4j:slf4j-api:2.0.13 (71 constraints: a1bfff9b) -org.tallison:isoparser:1.9.41.7 (1 constraints: fb0c5528) -org.tallison:jmatio:1.5 (1 constraints: ff0b57e9) -org.tallison:metadata-extractor:2.17.1.0 (1 constraints: f00c3b28) -org.tallison.xmp:xmpcore-shaded:6.1.10 (1 constraints: 300e8d49) -org.threeten:threetenbp:1.6.9 (4 constraints: 2833ea68) -org.tukaani:xz:1.9 (1 constraints: 030c5be9) -org.xerial.snappy:snappy-java:1.1.10.5 (6 constraints: 17552375) -software.amazon.awssdk:annotations:2.26.19 (28 constraints: 48a79471) -software.amazon.awssdk:apache-client:2.26.19 (4 constraints: 112adae3) -software.amazon.awssdk:arns:2.26.19 (2 constraints: 231878c1) -software.amazon.awssdk:auth:2.26.19 (5 constraints: 51386041) -software.amazon.awssdk:aws-core:2.26.19 (6 constraints: 044e3321) -software.amazon.awssdk:aws-query-protocol:2.26.19 (3 constraints: 5e2a17de) -software.amazon.awssdk:aws-xml-protocol:2.26.19 (2 constraints: 231878c1) -software.amazon.awssdk:bom:2.26.19 (1 constraints: 7605bc40) -software.amazon.awssdk:checksums:2.26.19 (4 constraints: 903650f6) -software.amazon.awssdk:checksums-spi:2.26.19 (5 constraints: 75453fbd) -software.amazon.awssdk:crt-core:2.26.19 (1 constraints: c60ba1f9) -software.amazon.awssdk:endpoints-spi:2.26.19 (5 constraints: 13415275) -software.amazon.awssdk:http-auth:2.26.19 (5 constraints: ad3ff879) -software.amazon.awssdk:http-auth-aws:2.26.19 (5 constraints: a43f775d) -software.amazon.awssdk:http-auth-spi:2.26.19 (8 constraints: d86cf7dd) -software.amazon.awssdk:http-client-spi:2.26.19 (15 constraints: 86da972d) -software.amazon.awssdk:identity-spi:2.26.19 (9 constraints: 0f7d43c5) -software.amazon.awssdk:json-utils:2.26.19 (5 constraints: 833fb03f) -software.amazon.awssdk:metrics-spi:2.26.19 (7 constraints: 44622f16) -software.amazon.awssdk:profiles:2.26.19 (8 constraints: 6f611a4a) -software.amazon.awssdk:protocol-core:2.26.19 (5 constraints: 8f48485b) -software.amazon.awssdk:regions:2.26.19 (7 constraints: 4c50ddb1) -software.amazon.awssdk:retries:2.26.19 (3 constraints: d5284028) -software.amazon.awssdk:retries-spi:2.26.19 (6 constraints: 304feb5b) -software.amazon.awssdk:s3:2.26.19 (4 constraints: e72f16c1) -software.amazon.awssdk:sdk-core:2.26.19 (10 constraints: 92871ded) -software.amazon.awssdk:sts:2.26.19 (2 constraints: d3115915) -software.amazon.awssdk:third-party-jackson-core:2.26.19 (2 constraints: 951b3aa8) -software.amazon.awssdk:utils:2.26.19 (25 constraints: 737511fa) -software.amazon.eventstream:eventstream:1.0.1 (2 constraints: 2e1ae62b) -ua.net.nlp:morfologik-ukrainian-search:4.9.1 (1 constraints: d5126e1e) -xerces:xercesImpl:2.12.2 (1 constraints: 8e0c7d0e) - -[Test dependencies] -com.adobe.testing:s3mock:2.17.0 (1 constraints: b012901d) -com.adobe.testing:s3mock-junit4:2.17.0 (1 constraints: 3c05443b) -com.adobe.testing:s3mock-testsupport-common:2.17.0 (1 constraints: 7b0d9839) -com.amazonaws:aws-java-sdk-core:1.12.501 (2 constraints: b01a32b3) -com.amazonaws:aws-java-sdk-kms:1.12.501 (1 constraints: 060dbd37) -com.amazonaws:aws-java-sdk-s3:1.12.501 (1 constraints: 10136f43) -com.amazonaws:jmespath-java:1.12.501 (2 constraints: b01a32b3) -com.fasterxml.jackson.dataformat:jackson-dataformat-xml:2.18.0 (2 constraints: ab195b13) -com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.18.0 (4 constraints: 6e48dd35) -com.fasterxml.jackson.module:jackson-module-kotlin:2.18.0 (2 constraints: aa1d6d60) -com.fasterxml.jackson.module:jackson-module-parameter-names:2.18.0 (2 constraints: 0d248182) -com.google.cloud:google-cloud-nio:0.127.20 (1 constraints: c90e267b) -com.nimbusds:content-type:2.2 (1 constraints: d80b68eb) -com.nimbusds:lang-tag:1.7 (1 constraints: dc0b6aeb) -com.nimbusds:nimbus-jose-jwt:9.30.2 (1 constraints: 700c4b10) -com.nimbusds:oauth2-oidc-sdk:10.10.1 (1 constraints: 190f9b80) -com.squareup.okhttp3:mockwebserver:4.11.0 (1 constraints: ec0e9471) -io.github.microutils:kotlin-logging:3.0.5 (1 constraints: be0ea162) -io.github.microutils:kotlin-logging-jvm:3.0.5 (1 constraints: 810f8b7c) -io.micrometer:micrometer-core:1.9.12 (1 constraints: fe162919) -io.opentelemetry:opentelemetry-sdk-testing:1.40.0 (1 constraints: 920fe683) -jakarta.servlet:jakarta.servlet-api:4.0.4 (1 constraints: 961568b9) -jakarta.websocket:jakarta.websocket-api:1.1.2 (1 constraints: 92155ab9) -javax.inject:javax.inject:1 (1 constraints: 7a0df617) -net.bytebuddy:byte-buddy:1.14.15 (1 constraints: 760bb5e9) -net.bytebuddy:byte-buddy-agent:1.14.15 (1 constraints: 760bb5e9) -net.minidev:accessors-smart:2.4.9 (1 constraints: 500a92b8) -net.minidev:json-smart:2.4.10 (1 constraints: 400e9a7c) -no.nav.security:mock-oauth2-server:0.5.10 (1 constraints: 3805333b) -org.apache.hadoop:hadoop-client-minicluster:3.4.0 (1 constraints: 09050636) -org.apache.hadoop:hadoop-hdfs:3.4.0 (1 constraints: 09050636) -org.apache.hadoop:hadoop-minikdc:3.4.0 (1 constraints: 09050636) -org.apache.kerby:kerb-admin:2.0.3 (1 constraints: 870d902f) -org.apache.kerby:kerb-client:2.0.3 (1 constraints: 870d902f) -org.apache.kerby:kerb-common:2.0.3 (3 constraints: df2506b3) -org.apache.kerby:kerb-identity:2.0.3 (1 constraints: 620cbd02) -org.apache.kerby:kerb-server:2.0.3 (1 constraints: d40b6cf2) -org.apache.kerby:kerb-simplekdc:2.0.3 (1 constraints: df0d853e) -org.apache.tomcat.embed:tomcat-embed-el:9.0.76 (1 constraints: d41558cf) -org.bouncycastle:bcpkix-jdk18on:1.78.1 (1 constraints: 43055a3b) -org.bouncycastle:bcprov-jdk18on:1.78.1 (2 constraints: 851b50bd) -org.bouncycastle:bcutil-jdk18on:1.78.1 (1 constraints: c20d8144) -org.freemarker:freemarker:2.3.32 (1 constraints: f00e9371) -org.hdrhistogram:HdrHistogram:2.1.12 (1 constraints: 520d2029) -org.hsqldb:hsqldb:2.7.2 (1 constraints: 0d050c36) -org.jetbrains.kotlin:kotlin-reflect:1.8.22 (2 constraints: 6624c6e2) -org.latencyutils:LatencyUtils:2.0.3 (1 constraints: 210dcd1b) -org.mockito:mockito-core:5.12.0 (2 constraints: 3212891b) -org.mockito:mockito-subclass:5.12.0 (1 constraints: 3a05473b) -org.objenesis:objenesis:3.3 (1 constraints: b20a14bd) -org.springframework:spring-aop:5.3.28 (2 constraints: de1e8f9a) -org.springframework:spring-beans:5.3.28 (4 constraints: b03ac3c9) -org.springframework:spring-context:5.3.28 (2 constraints: 6f1fced2) -org.springframework:spring-core:5.3.28 (8 constraints: 0f7e33c8) -org.springframework:spring-expression:5.3.28 (2 constraints: de1e8f9a) -org.springframework:spring-jcl:5.3.28 (1 constraints: 540ea44f) -org.springframework:spring-web:5.3.28 (3 constraints: 6539c38e) -org.springframework:spring-webmvc:5.3.28 (1 constraints: de14709e) -org.springframework.boot:spring-boot:2.7.13 (4 constraints: 8f56c646) -org.springframework.boot:spring-boot-actuator:2.7.13 (1 constraints: 7419a3b8) -org.springframework.boot:spring-boot-actuator-autoconfigure:2.7.13 (1 constraints: fe162819) -org.springframework.boot:spring-boot-autoconfigure:2.7.13 (2 constraints: e12ccb5d) -org.springframework.boot:spring-boot-starter:2.7.13 (3 constraints: 2a41eac5) -org.springframework.boot:spring-boot-starter-actuator:2.7.13 (2 constraints: 7018b7d0) -org.springframework.boot:spring-boot-starter-jetty:2.7.13 (1 constraints: f30a39d6) -org.springframework.boot:spring-boot-starter-json:2.7.13 (1 constraints: d914679e) -org.springframework.boot:spring-boot-starter-logging:2.7.13 (1 constraints: 6e138c46) -org.springframework.boot:spring-boot-starter-web:2.7.13 (1 constraints: f30a39d6) -org.yaml:snakeyaml:1.30 (1 constraints: 0713d91f) -software.amazon.awssdk:url-connection-client:2.26.19 (2 constraints: 481f08f7) -software.amazon.ion:ion-java:1.0.2 (1 constraints: 720db831) +{ + "comment" : "An inventory of resolved dependency versions. Do not edit this file directly.", + "configurationGroups" : { + "consolidated_dependencies" : { + "biz.aQute.bnd:biz.aQute.bnd.annotation:6.4.1" : "5fc760f2,refs=1", + "com.adobe.testing:s3mock:2.17.0" : "1e12e466,refs=2", + "com.adobe.testing:s3mock-junit4:2.17.0" : "1e12e466,refs=2", + "com.adobe.testing:s3mock-testsupport-common:2.17.0" : "1e12e466,refs=2", + "com.adobe.xmp:xmpcore:6.1.10" : "50a667d1,refs=5", + "com.amazonaws:aws-java-sdk-core:1.12.501" : "1e12e466,refs=2", + "com.amazonaws:aws-java-sdk-kms:1.12.501" : "1e12e466,refs=2", + "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.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.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-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-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.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.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", + "com.github.stephenc.jcip:jcip-annotations:1.0-1" : "e9990913,refs=4", + "com.github.virtuald:curvesapi:1.07" : "50a667d1,refs=5", + "com.google.android:annotations:4.1.1.4" : "dd724fae,refs=6", + "com.google.api-client:google-api-client:2.6.0" : "784a94ea,refs=5", + "com.google.api.grpc:gapic-google-cloud-storage-v2:2.40.1-alpha" : "784a94ea,refs=5", + "com.google.api.grpc:grpc-google-cloud-storage-v2:2.40.1-alpha" : "784a94ea,refs=5", + "com.google.api.grpc:proto-google-cloud-storage-v2:2.40.1-alpha" : "784a94ea,refs=5", + "com.google.api.grpc:proto-google-common-protos:2.41.0" : "cef2dbfe,refs=8", + "com.google.api.grpc:proto-google-iam-v1:1.36.0" : "784a94ea,refs=5", + "com.google.api:api-common:2.33.0" : "784a94ea,refs=5", + "com.google.api:gax:2.50.0" : "784a94ea,refs=5", + "com.google.api:gax-grpc:2.50.0" : "784a94ea,refs=5", + "com.google.api:gax-httpjson:2.50.0" : "784a94ea,refs=5", + "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.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.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.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.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-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", + "com.googlecode.juniversalchardet:juniversalchardet:1.0.3" : "50a667d1,refs=5", + "com.googlecode.plist:dd-plist:1.24" : "50a667d1,refs=5", + "com.healthmarketscience.jackcess:jackcess:4.0.2" : "50a667d1,refs=5", + "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.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", + "com.nimbusds:lang-tag:1.7" : "4f81d786,refs=2", + "com.nimbusds:nimbus-jose-jwt:9.30.2" : "4f81d786,refs=2", + "com.nimbusds:oauth2-oidc-sdk:10.10.1" : "4f81d786,refs=2", + "com.pff:java-libpst:0.9.3" : "50a667d1,refs=5", + "com.rometools:rome:1.18.0" : "50a667d1,refs=5", + "com.rometools:rome-utils:1.18.0" : "50a667d1,refs=5", + "com.squareup.okhttp3:mockwebserver:4.11.0" : "4f81d786,refs=2", + "com.squareup.okhttp3:okhttp:4.12.0" : "b6a343e2,refs=5", + "com.squareup.okio:okio:3.6.0" : "b6a343e2,refs=5", + "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.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-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-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", + "edu.ucar:grib:4.5.5" : "50a667d1,refs=5", + "edu.ucar:httpservices:4.5.5" : "50a667d1,refs=5", + "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-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-json:4.2.26" : "0769b123,refs=5", + "io.dropwizard.metrics:metrics-jvm:4.2.26" : "dc28f153,refs=83", + "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.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", + "io.grpc:grpc-api:1.65.1" : "cef2dbfe,refs=8", + "io.grpc:grpc-auth:1.65.1" : "784a94ea,refs=5", + "io.grpc:grpc-bom:1.65.1" : "784a94ea,refs=5", + "io.grpc:grpc-context:1.65.1" : "cef2dbfe,refs=8", + "io.grpc:grpc-core:1.65.1" : "cef2dbfe,refs=8", + "io.grpc:grpc-googleapis:1.65.1" : "6fb73f3a,refs=3", + "io.grpc:grpc-grpclb:1.65.1" : "784a94ea,refs=5", + "io.grpc:grpc-inprocess:1.65.1" : "784a94ea,refs=5", + "io.grpc:grpc-netty:1.65.1" : "5fcc0587,refs=3", + "io.grpc:grpc-netty-shaded:1.65.1" : "6fb73f3a,refs=3", + "io.grpc:grpc-protobuf:1.65.1" : "cef2dbfe,refs=8", + "io.grpc:grpc-protobuf-lite:1.65.1" : "dd724fae,refs=6", + "io.grpc:grpc-rls:1.65.1" : "6fb73f3a,refs=3", + "io.grpc:grpc-services:1.65.1" : "6fb73f3a,refs=3", + "io.grpc:grpc-stub:1.65.1" : "cef2dbfe,refs=8", + "io.grpc:grpc-util:1.65.1" : "dd724fae,refs=6", + "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-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-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.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-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-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", + "io.opentelemetry:opentelemetry-exporter-sender-okhttp:1.40.0" : "5fcc0587,refs=3", + "io.opentelemetry:opentelemetry-sdk:1.40.0" : "0d28f997,refs=5", + "io.opentelemetry:opentelemetry-sdk-common:1.40.0" : "0d28f997,refs=5", + "io.opentelemetry:opentelemetry-sdk-extension-autoconfigure:1.40.0" : "0d28f997,refs=5", + "io.opentelemetry:opentelemetry-sdk-extension-autoconfigure-spi:1.40.0" : "0d28f997,refs=5", + "io.opentelemetry:opentelemetry-sdk-logs:1.40.0" : "0d28f997,refs=5", + "io.opentelemetry:opentelemetry-sdk-metrics:1.40.0" : "0d28f997,refs=5", + "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: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", + "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.servlet:jakarta.servlet-api:4.0.4" : "1e12e466,refs=2", + "jakarta.validation:jakarta.validation-api:3.0.2" : "ad8f08d7,refs=79", + "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.xml.bind:jakarta.xml.bind-api:2.3.3" : "debe9836,refs=7", + "javax.inject:javax.inject:1" : "a9dcee72,refs=28", + "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", + "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", + "net.java.dev.jna:jna:5.12.1" : "50a667d1,refs=5", + "net.minidev:accessors-smart:2.4.9" : "4f81d786,refs=2", + "net.minidev:json-smart:2.4.10" : "4f81d786,refs=2", + "net.sf.ehcache:ehcache-core:2.6.2" : "50a667d1,refs=5", + "net.sf.jopt-simple:jopt-simple:5.0.4" : "778d978f,refs=8", + "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.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", + "org.apache.calcite:calcite-linq4j:1.37.0" : "93acde90,refs=6", + "org.apache.commons:commons-collections4:4.4" : "515616b6,refs=7", + "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-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-recipes:5.7.1" : "280cfec8,refs=3", + "org.apache.curator:curator-test:5.7.1" : "3c9a199e,refs=29", + "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", + "org.apache.hadoop:hadoop-client-api:3.4.0" : "5f4312f3,refs=5", + "org.apache.hadoop:hadoop-client-minicluster:3.4.0" : "4985a322,refs=1", + "org.apache.hadoop:hadoop-client-runtime:3.4.0" : "26b9da63,refs=3", + "org.apache.hadoop:hadoop-common:3.4.0" : "bf04d2b8,refs=5", + "org.apache.hadoop:hadoop-hdfs:3.4.0" : "90aa62e6,refs=2", + "org.apache.hadoop:hadoop-minikdc:3.4.0" : "f7508386,refs=2", + "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.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", + "org.apache.kafka:kafka-group-coordinator:3.7.1" : "4bf37e93,refs=3", + "org.apache.kafka:kafka-metadata:3.7.1" : "4bf37e93,refs=3", + "org.apache.kafka:kafka-raft:3.7.1" : "4bf37e93,refs=3", + "org.apache.kafka:kafka-server:3.7.1" : "4bf37e93,refs=3", + "org.apache.kafka:kafka-server-common:3.7.1" : "4bf37e93,refs=3", + "org.apache.kafka:kafka-storage:3.7.1" : "4bf37e93,refs=3", + "org.apache.kafka:kafka-storage-api:3.7.1" : "4bf37e93,refs=3", + "org.apache.kafka:kafka-streams:3.7.1" : "934e1fc5,refs=4", + "org.apache.kafka:kafka-tools-api:3.7.1" : "4bf37e93,refs=3", + "org.apache.kafka:kafka_2.13:3.7.1" : "4bf37e93,refs=3", + "org.apache.kerby:kerb-admin:2.0.3" : "f7508386,refs=2", + "org.apache.kerby:kerb-client:2.0.3" : "f7508386,refs=2", + "org.apache.kerby:kerb-common:2.0.3" : "f7508386,refs=2", + "org.apache.kerby:kerb-core:2.0.3" : "1643ad05,refs=4", + "org.apache.kerby:kerb-crypto:2.0.3" : "1643ad05,refs=4", + "org.apache.kerby:kerb-identity:2.0.3" : "f7508386,refs=2", + "org.apache.kerby:kerb-server:2.0.3" : "f7508386,refs=2", + "org.apache.kerby:kerb-simplekdc:2.0.3" : "f7508386,refs=2", + "org.apache.kerby:kerb-util:2.0.3" : "1643ad05,refs=4", + "org.apache.kerby:kerby-asn1:2.0.3" : "1643ad05,refs=4", + "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.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-morfologik:9.11.1" : "727aea63,refs=7", + "org.apache.lucene:lucene-analysis-nori:9.11.1" : "ebd3db47,refs=77", + "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-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.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", + "org.apache.pdfbox:jempbox:1.8.16" : "50a667d1,refs=5", + "org.apache.pdfbox:pdfbox:2.0.26" : "50a667d1,refs=5", + "org.apache.pdfbox:pdfbox-tools:2.0.26" : "50a667d1,refs=5", + "org.apache.pdfbox:preflight:2.0.26" : "50a667d1,refs=5", + "org.apache.pdfbox:xmpbox:2.0.26" : "50a667d1,refs=5", + "org.apache.poi:poi:5.2.2" : "50a667d1,refs=5", + "org.apache.poi:poi-ooxml:5.2.2" : "50a667d1,refs=5", + "org.apache.poi:poi-ooxml-lite:5.2.2" : "50a667d1,refs=5", + "org.apache.poi:poi-scratchpad:5.2.2" : "50a667d1,refs=5", + "org.apache.sis.core:sis-feature:1.2" : "50a667d1,refs=5", + "org.apache.sis.core:sis-metadata:1.2" : "50a667d1,refs=5", + "org.apache.sis.core:sis-referencing:1.2" : "50a667d1,refs=5", + "org.apache.sis.core:sis-utility:1.2" : "50a667d1,refs=5", + "org.apache.sis.storage:sis-netcdf:1.2" : "50a667d1,refs=5", + "org.apache.sis.storage:sis-storage:1.2" : "50a667d1,refs=5", + "org.apache.tika:tika-core:1.28.5" : "b6f115a3,refs=10", + "org.apache.tika:tika-parsers:1.28.5" : "50a667d1,refs=5", + "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.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", + "org.bouncycastle:bcpkix-jdk18on:1.78.1" : "4f81d786,refs=2", + "org.bouncycastle:bcprov-jdk15on:1.70" : "8ba2f0f7,refs=6", + "org.bouncycastle:bcprov-jdk18on:1.78.1" : "4f81d786,refs=2", + "org.bouncycastle:bcutil-jdk15on:1.70" : "8ba2f0f7,refs=6", + "org.bouncycastle:bcutil-jdk18on:1.78.1" : "4f81d786,refs=2", + "org.brotli:dec:0.1.2" : "50a667d1,refs=5", + "org.carrot2:carrot2-core:4.5.1" : "f5acb352,refs=5", + "org.carrot2:morfologik-fsa:2.1.9" : "727aea63,refs=7", + "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.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.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: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-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-servlets:10.0.22" : "24396a00,refs=4", + "org.eclipse.jetty:jetty-util:10.0.22" : "84afbb60,refs=130", + "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.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.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.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", + "org.jetbrains.kotlin:kotlin-stdlib:1.9.10" : "b6a343e2,refs=5", + "org.jetbrains.kotlin:kotlin-stdlib-common:1.9.10" : "b6a343e2,refs=5", + "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.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.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", + "org.objenesis:objenesis:3.3" : "9e97e18c,refs=9", + "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.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.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", + "org.scala-lang.modules:scala-collection-compat_2.13:2.10.0" : "4bf37e93,refs=3", + "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.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", + "org.springframework.boot:spring-boot-autoconfigure:2.7.13" : "1e12e466,refs=2", + "org.springframework.boot:spring-boot-starter:2.7.13" : "1e12e466,refs=2", + "org.springframework.boot:spring-boot-starter-actuator:2.7.13" : "1e12e466,refs=2", + "org.springframework.boot:spring-boot-starter-jetty:2.7.13" : "1e12e466,refs=2", + "org.springframework.boot:spring-boot-starter-json:2.7.13" : "1e12e466,refs=2", + "org.springframework.boot:spring-boot-starter-logging:2.7.13" : "1e12e466,refs=2", + "org.springframework.boot:spring-boot-starter-web:2.7.13" : "1e12e466,refs=2", + "org.springframework:spring-aop:5.3.28" : "1e12e466,refs=2", + "org.springframework:spring-beans:5.3.28" : "1e12e466,refs=2", + "org.springframework:spring-context:5.3.28" : "1e12e466,refs=2", + "org.springframework:spring-core:5.3.28" : "1e12e466,refs=2", + "org.springframework:spring-expression:5.3.28" : "1e12e466,refs=2", + "org.springframework:spring-jcl:5.3.28" : "1e12e466,refs=2", + "org.springframework:spring-web:5.3.28" : "1e12e466,refs=2", + "org.springframework:spring-webmvc:5.3.28" : "1e12e466,refs=2", + "org.tallison.xmp:xmpcore-shaded:6.1.10" : "50a667d1,refs=5", + "org.tallison:isoparser:1.9.41.7" : "50a667d1,refs=5", + "org.tallison:jmatio:1.5" : "50a667d1,refs=5", + "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.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", + "software.amazon.awssdk:arns:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:auth:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:aws-core:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:aws-query-protocol:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:aws-xml-protocol:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:bom:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:checksums:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:checksums-spi:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:crt-core:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:endpoints-spi:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:http-auth:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:http-auth-aws:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:http-auth-spi:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:http-client-spi:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:identity-spi:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:json-utils:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:metrics-spi:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:profiles:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:protocol-core:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:regions:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:retries:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:retries-spi:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:s3:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:sdk-core:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:sts:2.26.19" : "7accccef,refs=3", + "software.amazon.awssdk:third-party-jackson-core:2.26.19" : "87cc13ff,refs=5", + "software.amazon.awssdk:url-connection-client:2.26.19" : "1e12e466,refs=2", + "software.amazon.awssdk:utils:2.26.19" : "87cc13ff,refs=5", + "software.amazon.eventstream:eventstream:1.0.1" : "87cc13ff,refs=5", + "software.amazon.ion:ion-java:1.0.2" : "1e12e466,refs=2", + "ua.net.nlp:morfologik-ukrainian-search:4.9.1" : "727aea63,refs=7", + "xerces:xercesImpl:2.12.2" : "50a667d1,refs=5" + } + }, + "because" : { + "015c5766" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "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" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "06ca9183" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "0769b123" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + } + ], + "08ef8dc6" : [ + { + "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: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" + } + ], + "0a82b27c" : [ + { + "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:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + } + ], + "0d28f997" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + } + ], + "0e779887" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "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" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "serverLib", + "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" : "serverLib", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "100652ac" : [ + { + "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" + }, + { + "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" : "solrCore", + "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", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "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" + }, + { + "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", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "1069c1cc" : [ + { + "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" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "serverLib", + "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" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "1640bbba" : [ + { + "configuration" : "solrPlatformLibs", + "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" : "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" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + } + ], + "1643ad05" : [ + { + "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" + } + ], + "17e13daa" : [ + { + "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" + }, + { + "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" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "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" + }, + { + "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" : "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:solrj-streaming" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "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" + }, + { + "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" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "1e12e466" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "1f5bde05" : [ + { + "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" + }, + { + "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", + "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" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "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" + } + ], + "21136b15" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:server" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "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: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" + } + ], + "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" + } + ], + "27f62655" : [ + { + "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" : "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: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" : "annotationProcessor", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:core" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:server" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules: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:opentelemetry" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" + } + ], + "36393977" : [ + { + "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", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "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" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "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" : "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:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "3ff3bc39" : [ + { + "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" : "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" : "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: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" + } + ], + "420fd813" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:api" + }, + { + "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" + }, + { + "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" : "solrCore", + "projectPath" : ":solr:server" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "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" + }, + { + "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" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "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" : [ + { + "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" + }, + { + "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" : "solrCore", + "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", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "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" : "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", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "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" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + } + ], + "58171492" : [ + { + "configuration" : "solrPlatformLibs", + "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" + }, + { + "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" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "serverLib", + "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" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "5b11e899" : [ + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "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: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" : "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" + }, + { + "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" + }, + { + "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" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "annotationProcessor", + "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" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:extraction" + }, + { + "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" : "annotationProcessor", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "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" : "annotationProcessor", + "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" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "annotationProcessor", + "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" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:langid" + }, + { + "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" : "annotationProcessor", + "projectPath" : ":solr:modules:ltr" + }, + { + "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" : "annotationProcessor", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "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" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "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" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" + }, + { + "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" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "5d98342f" : [ + { + "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:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "5e82f1c0" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" + }, + { + "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" : "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" + }, + { + "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" : "testCompileClasspath", + "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" : "testCompileClasspath", + "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" : "testCompileClasspath", + "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" : "testCompileClasspath", + "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" : "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" + }, + { + "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", + "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" + }, + { + "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", + "projectPath" : ":solr:modules:langid" + }, + { + "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: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" + } + ], + "5f4312f3" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + } + ], + "5f62bd8e" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "5fb053e8" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "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", + "projectPath" : ":solr:server" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:server" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:server" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "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" + }, + { + "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" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "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" + } + ], + "6351de37" : [ + { + "configuration" : "solrPlatformLibs", + "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" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + } + ], + "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" + } + ], + "6a8501ec" : [ + { + "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" : "solrCore", + "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", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "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" + }, + { + "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", + "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" : "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", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "6ac4140f" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "libExt", + "projectPath" : ":solr:server" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + } + ], + "6fb73f3a" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + } + ], + "703dff64" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" + }, + { + "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" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:server" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "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" + }, + { + "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" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "727aea63" : [ + { + "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" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "72c9c512" : [ + { + "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: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" + } + ], + "7413b098" : [ + { + "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" : "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" : "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" : "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" + }, + { + "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" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "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" + }, + { + "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" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "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" : "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:opentelemetry" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" + }, + { + "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" + } + ], + "761c3c3c" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + } + ], + "76db8e26" : [ + { + "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" + }, + { + "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" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:server" + }, + { + "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" + }, + { + "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: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" + } + ], + "778d978f" : [ + { + "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" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + } + ], + "781655d3" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + } + ], + "784a94ea" : [ + { + "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" + } + ], + "78dd58c9" : [ + { + "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: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" + } + ], + "7accccef" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "7bb67147" : [ + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "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: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" + } + ], + "7df0e72e" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "7f2dd9d5" : [ + { + "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" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "solrCore", + "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", + "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" : "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", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "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" + } + ], + "84afbb60" : [ + { + "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" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:server" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:server" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "serverLib", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "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" + }, + { + "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" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "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" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "87cd582a" : [ + { + "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" : "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" : "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" : "serverLib", + "projectPath" : ":solr:webapp" + }, + { + "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" + }, + { + "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" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "8b517977" : [ + { + "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", + "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: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" + }, + { + "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: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" + } + ], + "970f2ee7" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:solrj-streaming" + } + ], + "99b82a6c" : [ + { + "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" : "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" : "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" : "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" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "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" + } + ], + "9bcc8206" : [ + { + "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:jwt-auth" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + } + ], + "9e97e18c" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" + }, + { + "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" + } + ], + "a05ffa28" : [ + { + "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" + }, + { + "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" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solr-ref-guide" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:solrj-streaming" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj-zookeeper" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testCompileClasspath", + "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:sql" + } + ], + "a6fb6a35" : [ + { + "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" : "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" + }, + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "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: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" : "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" : "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:opentelemetry" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" + } + ], + "aa7a59c6" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + } + ], + "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" + } + ], + "ad8f08d7" : [ + { + "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: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" + } + ], + "b3b7541b" : [ + { + "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" : "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" : "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: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" + } + ], + "b4755bf3" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "b57e9bf6" : [ + { + "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" + }, + { + "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" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:server" + }, + { + "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" + }, + { + "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: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" + } + ], + "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" + } + ], + "b6f115a3" : [ + { + "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: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" + } + ], + "bc8e8214" : [ + { + "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" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "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: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" + }, + { + "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:opentelemetry" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "annotationProcessor", + "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" + } + ], + "c6acb8a9" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + } + ], + "c718e885" : [ + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + } + ], + "c77c5ec7" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + } + ], + "cef2dbfe" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + } + ], + "d008b72a" : [ + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" + }, + { + "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" : "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" + }, + { + "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" : "testCompileClasspath", + "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" : "testCompileClasspath", + "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" : "testCompileClasspath", + "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" : "testCompileClasspath", + "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" : "testCompileClasspath", + "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" : "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", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "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", + "projectPath" : ":solr:modules:langid" + }, + { + "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: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" + } + ], + "d3d191b2" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "dc28f153" : [ + { + "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" : "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: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" + } + ], + "dd724fae" : [ + { + "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:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + } + ], + "ddc123c8" : [ + { + "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" : "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" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "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" : "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", + "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" + } + ], + "debe9836" : [ + { + "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:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "e19ba4dc" : [ + { + "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" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:server" + }, + { + "configuration" : "testRuntimeClasspath", + "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" : "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" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "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" + } + ], + "e2f3f42e" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + } + ], + "e5b524d7" : [ + { + "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:opentelemetry" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" + } + ], + "e6d93f27" : [ + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "e80f7a3a" : [ + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:api" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:api" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:benchmark" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:core" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:cross-dc-manager" + }, + { + "configuration" : "runtimeClasspath", + "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" : "annotationProcessor", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:server" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "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" : "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" + }, + { + "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" : "annotationProcessor", + "projectPath" : ":solr:modules:clustering" + }, + { + "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" : "annotationProcessor", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "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" : "annotationProcessor", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "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" : "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" + }, + { + "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" : "annotationProcessor", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "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" : "annotationProcessor", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "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" + }, + { + "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" : "annotationProcessor", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "annotationProcessor", + "projectPath" : ":solr:modules:sql" + }, + { + "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" + } + ], + "e972cbed" : [ + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:hdfs" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hdfs" + } + ], + "e9990913" : [ + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:core" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:solrj" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:jwt-auth" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:jwt-auth" + } + ], + "ebd3db47" : [ + { + "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" : "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: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" + } + ], + "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" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:hadoop-auth" + } + ], + "f83d8628" : [ + { + "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" : "solrCore", + "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", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:test-framework" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:webapp" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:analysis-extras" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:clustering" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:cross-dc" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "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" : "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", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:langid" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:ltr" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:opentelemetry" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:scripting" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:sql" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:sql" + } + ], + "f9ff6c21" : [ + { + "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" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "solrCore", + "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", + "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: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" + } + ], + "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" : [ + { + "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" : "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" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:prometheus-exporter" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:server" + }, + { + "configuration" : "solrCore", + "projectPath" : ":solr:server" + }, + { + "configuration" : "testRuntimeClasspath", + "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" + }, + { + "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" : "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", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "solrPlatformLibs", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testCompileClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "testRuntimeClasspath", + "projectPath" : ":solr:modules:extraction" + }, + { + "configuration" : "compileClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeClasspath", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "configuration" : "runtimeLibs", + "projectPath" : ":solr:modules:gcs-repository" + }, + { + "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" + }, + { + "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", + "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" + }, + { + "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", + "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" : "compileClasspath", + "projectPath" : ":solr:modules:s3-repository" + }, + { + "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" + } + ] + } +} \ No newline at end of file diff --git a/versions.props b/versions.props deleted file mode 100644 index 946b3d97e6d..00000000000 --- a/versions.props +++ /dev/null @@ -1,76 +0,0 @@ -# The lines in this file needs to be lexicographically sorted. -# Please only add direct dependencies. Overrides of transitive versions should be called out in a comment. -biz.aQute.bnd:biz.aQute.bnd.annotation=6.4.1 -com.adobe.testing:s3mock-junit4=2.17.0 -com.carrotsearch.randomizedtesting:*=2.8.1 -com.carrotsearch:hppc=0.10.0 -com.cybozu.labs:langdetect=1.1-20120112 -com.fasterxml.jackson:jackson-bom=2.18.0 -com.github.ben-manes.caffeine:caffeine=3.1.8 -com.github.spotbugs:*=4.8.6 -com.github.stephenc.jcip:jcip-annotations=1.0-1 -com.google.cloud:google-cloud-bom=0.224.0 -com.google.errorprone:*=2.31.0 -com.google.guava:guava=32.1.3-jre -com.google.re2j:re2j=1.7 -com.j256.simplemagic:simplemagic=1.17 -com.jayway.jsonpath:json-path=2.9.0 -com.lmax:disruptor=3.4.4 -com.tdunning:t-digest=3.3 -commons-cli:commons-cli=1.9.0 -commons-codec:commons-codec=1.17.1 -commons-collections:commons-collections=3.2.2 -commons-io:commons-io=2.15.1 -io.dropwizard.metrics:*=4.2.26 -io.grpc:grpc-*=1.65.1 -io.netty:*=4.1.114.Final -io.opentelemetry:opentelemetry-bom=1.40.0 -io.prometheus:*=0.16.0 -io.swagger.core.v3:*=2.2.22 -jakarta.ws.rs:jakarta.ws.rs-api=3.1.0 -junit:junit=4.13.2 -net.thisptr:jackson-jq=0.0.13 -no.nav.security:mock-oauth2-server=0.5.10 -org.apache.calcite.avatica:avatica-core=1.25.0 -org.apache.calcite:*=1.37.0 -org.apache.commons:commons-collections4=4.4 -org.apache.commons:commons-compress=1.26.1 -org.apache.commons:commons-configuration2=2.11.0 -org.apache.commons:commons-exec=1.4.0 -org.apache.commons:commons-lang3=3.15.0 -org.apache.commons:commons-math3=3.6.1 -org.apache.curator:*=5.7.1 -org.apache.hadoop.thirdparty:*=1.2.0 -org.apache.hadoop:*=3.4.0 -org.apache.httpcomponents:httpclient=4.5.14 -org.apache.httpcomponents:httpcore=4.4.16 -org.apache.httpcomponents:httpmime=4.5.14 -org.apache.kafka:*=3.7.1 -org.apache.kerby:*=1.0.1 -org.apache.logging.log4j:*=2.21.0 -org.apache.lucene:*=9.11.1 -org.apache.tika:*=1.28.5 -org.apache.tomcat:annotations-api=6.0.53 -org.apache.zookeeper:*=3.9.2 -org.bitbucket.b_c:jose4j=0.9.6 -org.bouncycastle:bcpkix-jdk18on=1.78.1 -org.carrot2:carrot2-core=4.5.1 -org.codehaus.woodstox:stax2-api=4.2.2 -org.eclipse.jetty*:*=10.0.22 -org.eclipse.jetty.toolchain:jetty-servlet-api=4.0.6 -org.glassfish.hk2*:*=3.1.1 -org.glassfish.hk2.external:jakarta.inject=2.6.1 -org.glassfish.jersey*:*=3.1.9 -org.glassfish.jersey.containers:jersey-container-jetty-http=2.39.1 -org.hamcrest:*=3.0 -org.hsqldb:hsqldb=2.7.2 -org.immutables:value-annotations=2.10.1 -org.jctools:jctools-core=4.0.5 -org.mockito:mockito*=5.12.0 -org.openjdk.jmh:*=1.37 -org.osgi:osgi.annotation=8.1.0 -org.quicktheories:quicktheories=0.26 -org.semver4j:semver4j=5.3.0 -org.slf4j:*=2.0.13 -org.xerial.snappy:snappy-java=1.1.10.5 -software.amazon.awssdk:*=2.26.19 From 586ed007925cfb3a52f791fa1e3facc1b75fe397 Mon Sep 17 00:00:00 2001 From: Eric Pugh Date: Sat, 16 Nov 2024 08:04:03 -0500 Subject: [PATCH 06/33] SOLR-17490: Check for existence of perl executable and skip if it doesnt exist (#2753) --- gradle/documentation/changes-to-html.gradle | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/gradle/documentation/changes-to-html.gradle b/gradle/documentation/changes-to-html.gradle index 3b4ca69bf9d..af9d1b5fa9a 100644 --- a/gradle/documentation/changes-to-html.gradle +++ b/gradle/documentation/changes-to-html.gradle @@ -76,6 +76,13 @@ class ChangesToHtmlTask extends DefaultTask { def toHtml(File versionsFile) { def output = new ByteArrayOutputStream() + + // Check if the perl executable exists + if (!perlExists()) { + logger.warn("WARNING: Perl is not installed, skipping creating Changes.html") + return + } + def result = project.exec { executable project.externalTool("perl") standardInput changesFile.newInputStream() @@ -114,4 +121,14 @@ class ChangesToHtmlTask extends DefaultTask { throw new GradleException("Changes file ${changesFile} or Doap file ${changesDoapFile} not found.") } } + + def perlExists() { + try { + def process = "perl -v".execute() + process.waitFor() + return process.exitValue() == 0 + } catch (Exception e) { + return false + } + } } From 72cc2756a7befcdb1e9fff5275261695054bd152 Mon Sep 17 00:00:00 2001 From: James Dyer Date: Tue, 19 Nov 2024 09:20:25 -0600 Subject: [PATCH 07/33] SOLR-17516: LBHttpSolrClient: support HttpJdkSolrClient (Generic Version) (#2828) --- solr/CHANGES.txt | 4 +- .../handler/component/HttpShardHandler.java | 3 +- .../component/HttpShardHandlerFactory.java | 4 +- .../solrj/impl/CloudHttp2SolrClient.java | 6 +- .../client/solrj/impl/Http2SolrClient.java | 4 - .../client/solrj/impl/HttpJdkSolrClient.java | 28 +++-- .../client/solrj/impl/HttpSolrClientBase.java | 4 + .../client/solrj/impl/LBHttp2SolrClient.java | 33 ++--- .../solr/client/solrj/impl/LBSolrClient.java | 13 +- .../solrj/impl/HttpJdkSolrClientTest.java | 102 ++++------------ .../LBHttp2SolrClientIntegrationTest.java} | 112 +++++++++++------ .../solrj/impl/LBHttp2SolrClientTest.java | 115 ++++++++++++++++-- .../client/solrj/impl/MockTrustManager.java | 100 +++++++++++++++ 13 files changed, 363 insertions(+), 165 deletions(-) rename solr/solrj/src/test/org/apache/solr/client/solrj/{TestLBHttp2SolrClient.java => impl/LBHttp2SolrClientIntegrationTest.java} (77%) create mode 100644 solr/solrj/src/test/org/apache/solr/client/solrj/impl/MockTrustManager.java diff --git a/solr/CHANGES.txt b/solr/CHANGES.txt index 93e737a543d..05574f64371 100644 --- a/solr/CHANGES.txt +++ b/solr/CHANGES.txt @@ -32,6 +32,8 @@ Improvements * SOLR-17495: Change Solr CLI delete command to not delete configs by default. Decouple lifecycle of collections from configsets. (Eric Pugh) +* SOLR-17516: `LBHttp2SolrClient` is now generic, adding support for `HttpJdkSolrClient`. (James Dyer) + Optimizations --------------------- (No changes) @@ -71,7 +73,7 @@ Deprecation Removals in WordBreakSolrSpellChecker (Andrey Bozhko via Eric Pugh) * SOLR-14763: Remove deprecated asynchronous request methods from `Http2SolrClient`, `HttpJdkSolrClient` and `LBHttp2SolrClient` - in favor of the new CompletableFuture based methods. Remove the related deprecated interfaces `AsyncListener` and ``Cancellable` + in favor of the new CompletableFuture based methods. Remove the related deprecated interfaces `AsyncListener` and `Cancellable` (James Dyer) * SOLR-14115: Remove deprecated zkcli script in favour of equivalent bin/solr sub commmands. (Eric Pugh) diff --git a/solr/core/src/java/org/apache/solr/handler/component/HttpShardHandler.java b/solr/core/src/java/org/apache/solr/handler/component/HttpShardHandler.java index 219197d8cd8..7592eed86fc 100644 --- a/solr/core/src/java/org/apache/solr/handler/component/HttpShardHandler.java +++ b/solr/core/src/java/org/apache/solr/handler/component/HttpShardHandler.java @@ -31,6 +31,7 @@ import net.jcip.annotations.NotThreadSafe; import org.apache.solr.client.solrj.SolrRequest; import org.apache.solr.client.solrj.SolrResponse; +import org.apache.solr.client.solrj.impl.Http2SolrClient; import org.apache.solr.client.solrj.impl.LBHttp2SolrClient; import org.apache.solr.client.solrj.impl.LBSolrClient; import org.apache.solr.client.solrj.request.QueryRequest; @@ -113,7 +114,7 @@ public class HttpShardHandler extends ShardHandler { protected AtomicInteger pending; private final Map> shardToURLs; - protected LBHttp2SolrClient lbClient; + protected LBHttp2SolrClient lbClient; public HttpShardHandler(HttpShardHandlerFactory httpShardHandlerFactory) { this.httpShardHandlerFactory = httpShardHandlerFactory; diff --git a/solr/core/src/java/org/apache/solr/handler/component/HttpShardHandlerFactory.java b/solr/core/src/java/org/apache/solr/handler/component/HttpShardHandlerFactory.java index 2bfc4cb236a..ac7dc0cf8e0 100644 --- a/solr/core/src/java/org/apache/solr/handler/component/HttpShardHandlerFactory.java +++ b/solr/core/src/java/org/apache/solr/handler/component/HttpShardHandlerFactory.java @@ -84,7 +84,7 @@ public class HttpShardHandlerFactory extends ShardHandlerFactory protected volatile Http2SolrClient defaultClient; protected InstrumentedHttpListenerFactory httpListenerFactory; - protected LBHttp2SolrClient loadbalancer; + protected LBHttp2SolrClient loadbalancer; int corePoolSize = 0; int maximumPoolSize = Integer.MAX_VALUE; @@ -314,7 +314,7 @@ public void init(PluginInfo info) { .withMaxConnectionsPerHost(maxConnectionsPerHost) .build(); this.defaultClient.addListenerFactory(this.httpListenerFactory); - this.loadbalancer = new LBHttp2SolrClient.Builder(defaultClient).build(); + this.loadbalancer = new LBHttp2SolrClient.Builder(defaultClient).build(); initReplicaListTransformers(getParameter(args, "replicaRouting", null, sb)); diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/CloudHttp2SolrClient.java b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/CloudHttp2SolrClient.java index 92da218d15c..523c46b844c 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/CloudHttp2SolrClient.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/CloudHttp2SolrClient.java @@ -40,7 +40,7 @@ public class CloudHttp2SolrClient extends CloudSolrClient { private final ClusterStateProvider stateProvider; - private final LBHttp2SolrClient lbClient; + private final LBHttp2SolrClient lbClient; private final Http2SolrClient myClient; private final boolean clientIsInternal; @@ -73,7 +73,7 @@ protected CloudHttp2SolrClient(Builder builder) { // locks. this.locks = objectList(builder.parallelCacheRefreshesLocks); - this.lbClient = new LBHttp2SolrClient.Builder(myClient).build(); + this.lbClient = new LBHttp2SolrClient.Builder(myClient).build(); } private Http2SolrClient createOrGetHttpClientFromBuilder(Builder builder) { @@ -149,7 +149,7 @@ public void close() throws IOException { } @Override - public LBHttp2SolrClient getLbClient() { + public LBHttp2SolrClient getLbClient() { return lbClient; } diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/Http2SolrClient.java b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/Http2SolrClient.java index e3f974e41e3..fb2eb1a123f 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/Http2SolrClient.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/Http2SolrClient.java @@ -831,10 +831,6 @@ protected String allProcessorSupportedContentTypesCommaDelimited( .collect(Collectors.joining(", ")); } - protected RequestWriter getRequestWriter() { - return requestWriter; - } - /** * An Http2SolrClient that doesn't close or cleanup any resources * diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/HttpJdkSolrClient.java b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/HttpJdkSolrClient.java index d3610f8d544..1127b3fd1a1 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/HttpJdkSolrClient.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/HttpJdkSolrClient.java @@ -138,7 +138,7 @@ protected HttpJdkSolrClient(String serverBaseUrl, HttpJdkSolrClient.Builder buil public CompletableFuture> requestAsync( final SolrRequest solrRequest, String collection) { try { - PreparedRequest pReq = prepareRequest(solrRequest, collection); + PreparedRequest pReq = prepareRequest(solrRequest, collection, null); return httpClient .sendAsync(pReq.reqb.build(), HttpResponse.BodyHandlers.ofInputStream()) .thenApply( @@ -157,10 +157,10 @@ public CompletableFuture> requestAsync( } } - @Override - public NamedList request(SolrRequest solrRequest, String collection) + protected NamedList requestWithBaseUrl( + String baseUrl, SolrRequest solrRequest, String collection) throws SolrServerException, IOException { - PreparedRequest pReq = prepareRequest(solrRequest, collection); + PreparedRequest pReq = prepareRequest(solrRequest, collection, baseUrl); HttpResponse response = null; try { response = httpClient.send(pReq.reqb.build(), HttpResponse.BodyHandlers.ofInputStream()); @@ -173,8 +173,8 @@ public NamedList request(SolrRequest solrRequest, String collection) "Timeout occurred while waiting response from server at: " + pReq.url, e); } catch (SolrException se) { throw se; - } catch (RuntimeException re) { - throw new SolrServerException(re); + } catch (RuntimeException e) { + throw new SolrServerException(e); } finally { if (pReq.contentWritingFuture != null) { pReq.contentWritingFuture.cancel(true); @@ -192,13 +192,25 @@ public NamedList request(SolrRequest solrRequest, String collection) } } - private PreparedRequest prepareRequest(SolrRequest solrRequest, String collection) + @Override + public NamedList request(SolrRequest solrRequest, String collection) + throws SolrServerException, IOException { + return requestWithBaseUrl(null, solrRequest, collection); + } + + private PreparedRequest prepareRequest( + SolrRequest solrRequest, String collection, String overrideBaseUrl) throws SolrServerException, IOException { checkClosed(); if (ClientUtils.shouldApplyDefaultCollection(collection, solrRequest)) { collection = defaultCollection; } - String url = getRequestUrl(solrRequest, collection); + String url; + if (overrideBaseUrl != null) { + url = ClientUtils.buildRequestUrl(solrRequest, overrideBaseUrl, collection); + } else { + url = getRequestUrl(solrRequest, collection); + } ResponseParser parserToUse = responseParser(solrRequest); ModifiableSolrParams queryParams = initializeSolrParams(solrRequest, parserToUse); var reqb = HttpRequest.newBuilder(); diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/HttpSolrClientBase.java b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/HttpSolrClientBase.java index 27e56375c2d..8683b965ad0 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/HttpSolrClientBase.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/HttpSolrClientBase.java @@ -120,6 +120,10 @@ protected ResponseParser responseParser(SolrRequest solrRequest) { return solrRequest.getResponseParser() == null ? this.parser : solrRequest.getResponseParser(); } + protected RequestWriter getRequestWriter() { + return requestWriter; + } + // TODO: Remove this for 10.0, there is a typo in the method name @Deprecated(since = "9.8", forRemoval = true) protected ModifiableSolrParams initalizeSolrParams( diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/LBHttp2SolrClient.java b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/LBHttp2SolrClient.java index cb06c9d0c27..2c926a26261 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/LBHttp2SolrClient.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/LBHttp2SolrClient.java @@ -37,9 +37,8 @@ import org.slf4j.MDC; /** - * LBHttp2SolrClient or "LoadBalanced LBHttp2SolrClient" is a load balancing wrapper around {@link - * Http2SolrClient}. This is useful when you have multiple Solr endpoints and requests need to be - * Load Balanced among them. + * This "LoadBalanced Http Solr Client" is a load balancing wrapper around a Http Solr Client. This + * is useful when you have multiple Solr endpoints and requests need to be Load Balanced among them. * *

Do NOT use this class for indexing in leader/follower scenarios since documents must be * sent to the correct leader; no inter-node routing is done. @@ -95,12 +94,14 @@ * * @since solr 8.0 */ -public class LBHttp2SolrClient extends LBSolrClient { - private final Http2SolrClient solrClient; +public class LBHttp2SolrClient extends LBSolrClient { - private LBHttp2SolrClient(Builder builder) { + protected final C solrClient; + + @SuppressWarnings("unchecked") + private LBHttp2SolrClient(Builder builder) { super(Arrays.asList(builder.solrEndpoints)); - this.solrClient = builder.http2SolrClient; + this.solrClient = (C) builder.solrClient; this.aliveCheckIntervalMillis = builder.aliveCheckIntervalMillis; this.defaultCollection = builder.defaultCollection; } @@ -289,16 +290,16 @@ private void onFailedRequest( } } - public static class Builder { + public static class Builder { - private final Http2SolrClient http2SolrClient; - private final Endpoint[] solrEndpoints; + private final C solrClient; + private final LBSolrClient.Endpoint[] solrEndpoints; private long aliveCheckIntervalMillis = TimeUnit.MILLISECONDS.convert(60, TimeUnit.SECONDS); // 1 minute between checks protected String defaultCollection; - public Builder(Http2SolrClient http2Client, Endpoint... endpoints) { - this.http2SolrClient = http2Client; + public Builder(C solrClient, Endpoint... endpoints) { + this.solrClient = solrClient; this.solrEndpoints = endpoints; } @@ -308,7 +309,7 @@ public Builder(Http2SolrClient http2Client, Endpoint... endpoints) { * * @param aliveCheckInterval how often to ping for aliveness */ - public LBHttp2SolrClient.Builder setAliveCheckInterval(int aliveCheckInterval, TimeUnit unit) { + public Builder setAliveCheckInterval(int aliveCheckInterval, TimeUnit unit) { if (aliveCheckInterval <= 0) { throw new IllegalArgumentException( "Alive check interval must be " + "positive, specified value = " + aliveCheckInterval); @@ -318,13 +319,13 @@ public LBHttp2SolrClient.Builder setAliveCheckInterval(int aliveCheckInterval, T } /** Sets a default for core or collection based requests. */ - public LBHttp2SolrClient.Builder withDefaultCollection(String defaultCoreOrCollection) { + public Builder withDefaultCollection(String defaultCoreOrCollection) { this.defaultCollection = defaultCoreOrCollection; return this; } - public LBHttp2SolrClient build() { - return new LBHttp2SolrClient(this); + public LBHttp2SolrClient build() { + return new LBHttp2SolrClient(this); } } } diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/LBSolrClient.java b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/LBSolrClient.java index e31f3c08393..6e691b802f0 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/LBSolrClient.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/LBSolrClient.java @@ -500,6 +500,8 @@ private NamedList doRequest( if (solrClient instanceof Http2SolrClient) { final var httpSolrClient = (Http2SolrClient) solrClient; return httpSolrClient.requestWithBaseUrl(baseUrl, (c) -> c.request(solrRequest, collection)); + } else if (solrClient instanceof HttpJdkSolrClient) { + return ((HttpJdkSolrClient) solrClient).requestWithBaseUrl(baseUrl, solrRequest, collection); } // Assume provided client already uses 'baseUrl' @@ -730,11 +732,20 @@ public NamedList request( if (e.getRootCause() instanceof IOException) { ex = e; moveAliveToDead(wrapper); - if (justFailed == null) justFailed = new HashMap<>(); + if (justFailed == null) { + justFailed = new HashMap<>(); + } justFailed.put(endpoint.getUrl(), wrapper); } else { throw e; } + } catch (IOException e) { + ex = e; + moveAliveToDead(wrapper); + if (justFailed == null) { + justFailed = new HashMap<>(); + } + justFailed.put(endpoint.getUrl(), wrapper); } catch (Exception e) { throw new SolrServerException(e); } diff --git a/solr/solrj/src/test/org/apache/solr/client/solrj/impl/HttpJdkSolrClientTest.java b/solr/solrj/src/test/org/apache/solr/client/solrj/impl/HttpJdkSolrClientTest.java index c3fb5609476..b3980ad44bc 100644 --- a/solr/solrj/src/test/org/apache/solr/client/solrj/impl/HttpJdkSolrClientTest.java +++ b/solr/solrj/src/test/org/apache/solr/client/solrj/impl/HttpJdkSolrClientTest.java @@ -20,10 +20,7 @@ import java.io.IOException; import java.net.CookieHandler; import java.net.CookieManager; -import java.net.Socket; import java.net.http.HttpClient; -import java.security.cert.CertificateException; -import java.security.cert.X509Certificate; import java.util.Arrays; import java.util.Collections; import java.util.Objects; @@ -31,51 +28,23 @@ import java.util.concurrent.ExecutorService; import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; -import javax.net.ssl.KeyManagerFactory; -import javax.net.ssl.SSLContext; -import javax.net.ssl.SSLEngine; -import javax.net.ssl.TrustManager; -import javax.net.ssl.X509ExtendedTrustManager; import org.apache.lucene.util.NamedThreadFactory; -import org.apache.solr.SolrTestCaseJ4; import org.apache.solr.client.solrj.ResponseParser; import org.apache.solr.client.solrj.SolrClient; import org.apache.solr.client.solrj.SolrQuery; import org.apache.solr.client.solrj.SolrRequest; import org.apache.solr.client.solrj.SolrServerException; +import org.apache.solr.client.solrj.request.QueryRequest; import org.apache.solr.client.solrj.request.RequestWriter; import org.apache.solr.client.solrj.response.SolrPingResponse; import org.apache.solr.common.params.CommonParams; import org.apache.solr.common.params.MapSolrParams; import org.apache.solr.common.util.ExecutorUtil; -import org.apache.solr.util.SSLTestConfig; import org.junit.After; -import org.junit.BeforeClass; import org.junit.Test; public class HttpJdkSolrClientTest extends HttpSolrClientTestBase { - private static SSLContext allTrustingSslContext; - - @BeforeClass - public static void beforeClass() { - try { - KeyManagerFactory keyManagerFactory = - KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm()); - SSLTestConfig stc = SolrTestCaseJ4.sslConfig; - keyManagerFactory.init(stc.defaultKeyStore(), stc.defaultKeyStorePassword().toCharArray()); - - SSLContext sslContext = SSLContext.getInstance("SSL"); - sslContext.init( - keyManagerFactory.getKeyManagers(), - new TrustManager[] {MOCK_TRUST_MANAGER}, - stc.notSecureSecureRandom()); - allTrustingSslContext = sslContext; - } catch (Exception e) { - throw new RuntimeException(e); - } - } - @After public void workaroundToReleaseThreads_noClosableUntilJava21() { Thread[] threads = new Thread[Thread.currentThread().getThreadGroup().activeCount()]; @@ -185,6 +154,25 @@ protected void testQuerySetup(SolrRequest.METHOD method, ResponseParser rp) thro } } + @Test + public void testRequestWithBaseUrl() throws Exception { + DebugServlet.clear(); + DebugServlet.addResponseHeader("Content-Type", "application/octet-stream"); + DebugServlet.responseBodyByQueryFragment.put("", javabinResponse()); + String someOtherUrl = getBaseUrl() + "/some/other/base/url"; + String intendedUrl = getBaseUrl() + DEBUG_SERVLET_PATH; + SolrQuery q = new SolrQuery("foo"); + q.setParam("a", MUST_ENCODE); + + HttpJdkSolrClient.Builder b = + builder(someOtherUrl).withResponseParser(new BinaryResponseParser()); + try (HttpJdkSolrClient client = b.build()) { + client.requestWithBaseUrl(intendedUrl, new QueryRequest(q, SolrRequest.METHOD.GET), null); + assertEquals( + client.getParser().getVersion(), DebugServlet.parameters.get(CommonParams.VERSION)[0]); + } + } + @Test public void testGetById() throws Exception { DebugServlet.clear(); @@ -541,7 +529,7 @@ protected String expectedUserAgent() { .withConnectionTimeout(connectionTimeout, TimeUnit.MILLISECONDS) .withIdleTimeout(socketTimeout, TimeUnit.MILLISECONDS) .withDefaultCollection(DEFAULT_CORE) - .withSSLContext(allTrustingSslContext); + .withSSLContext(MockTrustManager.ALL_TRUSTING_SSL_CONTEXT); return (B) b; } @@ -574,52 +562,4 @@ private byte[] javabinResponse() { + "6f 6e 21 32 e0 28 72 65 73 " + "70 6f 6e 73 65 0c 84 60 60 " + "00 01 80"; - - /** - * Taken from: https://www.baeldung.com/java-httpclient-ssl sec 4.1, 2024/02/12. This is an - * all-trusting Trust Manager. Works with self-signed certificates. - */ - private static final TrustManager MOCK_TRUST_MANAGER = - new X509ExtendedTrustManager() { - @Override - public void checkClientTrusted(X509Certificate[] chain, String authType, Socket socket) - throws CertificateException { - // no-op - } - - @Override - public void checkServerTrusted(X509Certificate[] chain, String authType, Socket socket) - throws CertificateException { - // no-op - } - - @Override - public void checkClientTrusted(X509Certificate[] chain, String authType, SSLEngine engine) - throws CertificateException { - // no-op - } - - @Override - public void checkServerTrusted(X509Certificate[] chain, String authType, SSLEngine engine) - throws CertificateException { - // no-op - } - - @Override - public java.security.cert.X509Certificate[] getAcceptedIssuers() { - return new java.security.cert.X509Certificate[0]; - } - - @Override - public void checkClientTrusted(X509Certificate[] chain, String authType) - throws CertificateException { - // no-op - } - - @Override - public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) - throws CertificateException { - // no-op - } - }; } diff --git a/solr/solrj/src/test/org/apache/solr/client/solrj/TestLBHttp2SolrClient.java b/solr/solrj/src/test/org/apache/solr/client/solrj/impl/LBHttp2SolrClientIntegrationTest.java similarity index 77% rename from solr/solrj/src/test/org/apache/solr/client/solrj/TestLBHttp2SolrClient.java rename to solr/solrj/src/test/org/apache/solr/client/solrj/impl/LBHttp2SolrClientIntegrationTest.java index c3464b73a82..a4cf3292e81 100644 --- a/solr/solrj/src/test/org/apache/solr/client/solrj/TestLBHttp2SolrClient.java +++ b/solr/solrj/src/test/org/apache/solr/client/solrj/impl/LBHttp2SolrClientIntegrationTest.java @@ -14,10 +14,11 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.apache.solr.client.solrj; +package org.apache.solr.client.solrj.impl; import java.io.File; import java.io.IOException; +import java.io.UncheckedIOException; import java.lang.invoke.MethodHandles; import java.nio.file.Files; import java.nio.file.Path; @@ -29,9 +30,9 @@ import java.util.concurrent.TimeUnit; import org.apache.lucene.util.IOUtils; import org.apache.solr.SolrTestCaseJ4; -import org.apache.solr.client.solrj.impl.Http2SolrClient; -import org.apache.solr.client.solrj.impl.LBHttp2SolrClient; -import org.apache.solr.client.solrj.impl.LBSolrClient; +import org.apache.solr.client.solrj.SolrClient; +import org.apache.solr.client.solrj.SolrQuery; +import org.apache.solr.client.solrj.SolrServerException; import org.apache.solr.client.solrj.response.QueryResponse; import org.apache.solr.client.solrj.response.SolrResponseBase; import org.apache.solr.common.SolrInputDocument; @@ -49,12 +50,11 @@ * * @since solr 1.4 */ -public class TestLBHttp2SolrClient extends SolrTestCaseJ4 { +public class LBHttp2SolrClientIntegrationTest extends SolrTestCaseJ4 { private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass()); SolrInstance[] solr = new SolrInstance[3]; - Http2SolrClient httpClient; // TODO: fix this test to not require FSDirectory static String savedFactory; @@ -79,11 +79,6 @@ public static void afterClass() { @Override public void setUp() throws Exception { super.setUp(); - httpClient = - new Http2SolrClient.Builder() - .withConnectionTimeout(1000, TimeUnit.MILLISECONDS) - .withIdleTimeout(2000, TimeUnit.MILLISECONDS) - .build(); for (int i = 0; i < solr.length; i++) { solr[i] = @@ -119,22 +114,46 @@ public void tearDown() throws Exception { aSolr.tearDown(); } } - httpClient.close(); super.tearDown(); } + private LBClientHolder client(LBSolrClient.Endpoint... baseSolrEndpoints) { + if (random().nextBoolean()) { + var delegateClient = + new Http2SolrClient.Builder() + .withConnectionTimeout(1000, TimeUnit.MILLISECONDS) + .withIdleTimeout(2000, TimeUnit.MILLISECONDS) + .build(); + var lbClient = + new LBHttp2SolrClient.Builder<>(delegateClient, baseSolrEndpoints) + .withDefaultCollection(solr[0].getDefaultCollection()) + .setAliveCheckInterval(500, TimeUnit.MILLISECONDS) + .build(); + return new LBClientHolder(lbClient, delegateClient); + } else { + var delegateClient = + new HttpJdkSolrClient.Builder() + .withConnectionTimeout(1000, TimeUnit.MILLISECONDS) + .withIdleTimeout(2000, TimeUnit.MILLISECONDS) + .withSSLContext(MockTrustManager.ALL_TRUSTING_SSL_CONTEXT) + .build(); + var lbClient = + new LBHttp2SolrClient.Builder<>(delegateClient, baseSolrEndpoints) + .withDefaultCollection(solr[0].getDefaultCollection()) + .setAliveCheckInterval(500, TimeUnit.MILLISECONDS) + .build(); + return new LBClientHolder(lbClient, delegateClient); + } + } + public void testSimple() throws Exception { final var baseSolrEndpoints = bootstrapBaseSolrEndpoints(solr.length); - try (LBHttp2SolrClient client = - new LBHttp2SolrClient.Builder(httpClient, baseSolrEndpoints) - .withDefaultCollection(solr[0].getDefaultCollection()) - .setAliveCheckInterval(500, TimeUnit.MILLISECONDS) - .build()) { + try (var h = client(baseSolrEndpoints)) { SolrQuery solrQuery = new SolrQuery("*:*"); Set names = new HashSet<>(); QueryResponse resp = null; for (int i = 0; i < solr.length; i++) { - resp = client.query(solrQuery); + resp = h.lbClient.query(solrQuery); assertEquals(10, resp.getResults().getNumFound()); names.add(resp.getResults().get(0).getFieldValue("name").toString()); } @@ -145,7 +164,7 @@ public void testSimple() throws Exception { solr[1].jetty = null; names.clear(); for (int i = 0; i < solr.length; i++) { - resp = client.query(solrQuery); + resp = h.lbClient.query(solrQuery); assertEquals(10, resp.getResults().getNumFound()); names.add(resp.getResults().get(0).getFieldValue("name").toString()); } @@ -158,7 +177,7 @@ public void testSimple() throws Exception { Thread.sleep(1200); names.clear(); for (int i = 0; i < solr.length; i++) { - resp = client.query(solrQuery); + resp = h.lbClient.query(solrQuery); assertEquals(10, resp.getResults().getNumFound()); names.add(resp.getResults().get(0).getFieldValue("name").toString()); } @@ -168,19 +187,15 @@ public void testSimple() throws Exception { public void testTwoServers() throws Exception { final var baseSolrEndpoints = bootstrapBaseSolrEndpoints(2); - try (LBHttp2SolrClient client = - new LBHttp2SolrClient.Builder(httpClient, baseSolrEndpoints) - .withDefaultCollection(solr[0].getDefaultCollection()) - .setAliveCheckInterval(500, TimeUnit.MILLISECONDS) - .build()) { + try (var h = client(baseSolrEndpoints)) { SolrQuery solrQuery = new SolrQuery("*:*"); QueryResponse resp = null; solr[0].jetty.stop(); solr[0].jetty = null; - resp = client.query(solrQuery); + resp = h.lbClient.query(solrQuery); String name = resp.getResults().get(0).getFieldValue("name").toString(); assertEquals("solr/collection11", name); - resp = client.query(solrQuery); + resp = h.lbClient.query(solrQuery); name = resp.getResults().get(0).getFieldValue("name").toString(); assertEquals("solr/collection11", name); solr[1].jetty.stop(); @@ -188,11 +203,11 @@ public void testTwoServers() throws Exception { solr[0].startJetty(); Thread.sleep(1200); try { - resp = client.query(solrQuery); + resp = h.lbClient.query(solrQuery); } catch (SolrServerException e) { // try again after a pause in case the error is lack of time to start server Thread.sleep(3000); - resp = client.query(solrQuery); + resp = h.lbClient.query(solrQuery); } name = resp.getResults().get(0).getFieldValue("name").toString(); assertEquals("solr/collection10", name); @@ -201,30 +216,28 @@ public void testTwoServers() throws Exception { public void testReliability() throws Exception { final var baseSolrEndpoints = bootstrapBaseSolrEndpoints(solr.length); - - try (LBHttp2SolrClient client = - new LBHttp2SolrClient.Builder(httpClient, baseSolrEndpoints) - .withDefaultCollection(solr[0].getDefaultCollection()) - .setAliveCheckInterval(500, TimeUnit.MILLISECONDS) - .build()) { + try (var h = client(baseSolrEndpoints)) { // Kill a server and test again solr[1].jetty.stop(); solr[1].jetty = null; // query the servers - for (int i = 0; i < solr.length; i++) client.query(new SolrQuery("*:*")); + for (int i = 0; i < solr.length; i++) { + h.lbClient.query(new SolrQuery("*:*")); + } // Start the killed server once again solr[1].startJetty(); // Wait for the alive check to complete - waitForServer(30, client, 3, solr[1].name); + waitForServer(30, h.lbClient, 3, solr[1].name); } } // wait maximum ms for serverName to come back up private void waitForServer( - int maxSeconds, LBHttp2SolrClient client, int nServers, String serverName) throws Exception { + int maxSeconds, LBHttp2SolrClient client, int nServers, String serverName) + throws Exception { final TimeOut timeout = new TimeOut(maxSeconds, TimeUnit.SECONDS, TimeSource.NANO_TIME); while (!timeout.hasTimedOut()) { QueryResponse resp; @@ -337,8 +350,27 @@ public void startJetty() throws Exception { fail("TESTING FAILURE: could not grab requested port."); } this.port = newPort; - // System.out.println("waiting........."); - // Thread.sleep(5000); + } + } + + private static class LBClientHolder implements AutoCloseable { + + final LBHttp2SolrClient lbClient; + final HttpSolrClientBase delegate; + + LBClientHolder(LBHttp2SolrClient lbClient, HttpSolrClientBase delegate) { + this.lbClient = lbClient; + this.delegate = delegate; + } + + @Override + public void close() { + lbClient.close(); + try { + delegate.close(); + } catch (IOException ioe) { + throw new UncheckedIOException(ioe); + } } } } diff --git a/solr/solrj/src/test/org/apache/solr/client/solrj/impl/LBHttp2SolrClientTest.java b/solr/solrj/src/test/org/apache/solr/client/solrj/impl/LBHttp2SolrClientTest.java index 3a93488e726..9d2019309b0 100644 --- a/solr/solrj/src/test/org/apache/solr/client/solrj/impl/LBHttp2SolrClientTest.java +++ b/solr/solrj/src/test/org/apache/solr/client/solrj/impl/LBHttp2SolrClientTest.java @@ -53,8 +53,8 @@ public void testLBHttp2SolrClientWithTheseParamNamesInTheUrl() { try (Http2SolrClient http2SolrClient = new Http2SolrClient.Builder(url).withTheseParamNamesInTheUrl(urlParamNames).build(); - LBHttp2SolrClient testClient = - new LBHttp2SolrClient.Builder(http2SolrClient, new LBSolrClient.Endpoint(url)) + LBHttp2SolrClient testClient = + new LBHttp2SolrClient.Builder<>(http2SolrClient, new LBSolrClient.Endpoint(url)) .build()) { assertArrayEquals( @@ -68,6 +68,90 @@ public void testLBHttp2SolrClientWithTheseParamNamesInTheUrl() { } } + @Test + public void testSynchronous() throws Exception { + LBSolrClient.Endpoint ep1 = new LBSolrClient.Endpoint("http://endpoint.one"); + LBSolrClient.Endpoint ep2 = new LBSolrClient.Endpoint("http://endpoint.two"); + List endpointList = List.of(ep1, ep2); + + Http2SolrClient.Builder b = + new Http2SolrClient.Builder("http://base.url").withConnectionTimeout(10, TimeUnit.SECONDS); + ; + try (MockHttpSolrClient client = new MockHttpSolrClient("http://base.url", b); + LBHttp2SolrClient testClient = + new LBHttp2SolrClient.Builder<>(client, ep1, ep2).build()) { + + String lastEndpoint = null; + for (int i = 0; i < 10; i++) { + String qValue = "Query Number: " + i; + QueryRequest queryRequest = new QueryRequest(new MapSolrParams(Map.of("q", qValue))); + LBSolrClient.Req req = new LBSolrClient.Req(queryRequest, endpointList); + LBSolrClient.Rsp response = testClient.request(req); + + String expectedEndpoint = + ep1.toString().equals(lastEndpoint) ? ep2.toString() : ep1.toString(); + assertEquals( + "There should be round-robin load balancing.", expectedEndpoint, response.server); + checkSynchonousResponseContent(response, qValue); + } + } + } + + @Test + public void testSynchronousWithFalures() throws Exception { + LBSolrClient.Endpoint ep1 = new LBSolrClient.Endpoint("http://endpoint.one"); + LBSolrClient.Endpoint ep2 = new LBSolrClient.Endpoint("http://endpoint.two"); + List endpointList = List.of(ep1, ep2); + + Http2SolrClient.Builder b = + new Http2SolrClient.Builder("http://base.url").withConnectionTimeout(10, TimeUnit.SECONDS); + ; + try (MockHttpSolrClient client = new MockHttpSolrClient("http://base.url", b); + LBHttp2SolrClient testClient = + new LBHttp2SolrClient.Builder<>(client, ep1, ep2).build()) { + + client.basePathToFail = ep1.getBaseUrl(); + String basePathToSucceed = ep2.getBaseUrl(); + String qValue = "First time"; + + for (int i = 0; i < 5; i++) { + LBSolrClient.Req req = + new LBSolrClient.Req( + new QueryRequest(new MapSolrParams(Map.of("q", qValue))), endpointList); + LBSolrClient.Rsp response = testClient.request(req); + assertEquals( + "The healthy node 'endpoint two' should have served the request: " + i, + basePathToSucceed, + response.server); + checkSynchonousResponseContent(response, qValue); + } + + client.basePathToFail = ep2.getBaseUrl(); + basePathToSucceed = ep1.getBaseUrl(); + qValue = "Second time"; + + for (int i = 0; i < 5; i++) { + LBSolrClient.Req req = + new LBSolrClient.Req( + new QueryRequest(new MapSolrParams(Map.of("q", qValue))), endpointList); + LBSolrClient.Rsp response = testClient.request(req); + assertEquals( + "The healthy node 'endpoint one' should have served the request: " + i, + basePathToSucceed, + response.server); + checkSynchonousResponseContent(response, qValue); + } + } + } + + private void checkSynchonousResponseContent(LBSolrClient.Rsp response, String qValue) { + assertEquals("There should be one element in the respnse.", 1, response.getResponse().size()); + assertEquals( + "The response key 'response' should echo the query.", + qValue, + response.getResponse().get("response")); + } + @Test public void testAsyncWithFailures() { @@ -81,8 +165,9 @@ public void testAsyncWithFailures() { Http2SolrClient.Builder b = new Http2SolrClient.Builder("http://base.url").withConnectionTimeout(10, TimeUnit.SECONDS); ; - try (MockHttp2SolrClient client = new MockHttp2SolrClient("http://base.url", b); - LBHttp2SolrClient testClient = new LBHttp2SolrClient.Builder(client, ep1, ep2).build()) { + try (MockHttpSolrClient client = new MockHttpSolrClient("http://base.url", b); + LBHttp2SolrClient testClient = + new LBHttp2SolrClient.Builder<>(client, ep1, ep2).build()) { for (int j = 0; j < 2; j++) { // first time Endpoint One will return error code 500. @@ -144,8 +229,9 @@ public void testAsync() { Http2SolrClient.Builder b = new Http2SolrClient.Builder("http://base.url").withConnectionTimeout(10, TimeUnit.SECONDS); - try (MockHttp2SolrClient client = new MockHttp2SolrClient("http://base.url", b); - LBHttp2SolrClient testClient = new LBHttp2SolrClient.Builder(client, ep1, ep2).build()) { + try (MockHttpSolrClient client = new MockHttpSolrClient("http://base.url", b); + LBHttp2SolrClient testClient = + new LBHttp2SolrClient.Builder<>(client, ep1, ep2).build()) { int limit = 10; // For simplicity use an even limit List> responses = new ArrayList<>(); @@ -200,7 +286,7 @@ public void testAsync() { } } - public static class MockHttp2SolrClient extends Http2SolrClient { + public static class MockHttpSolrClient extends Http2SolrClient { public List> lastSolrRequests = new ArrayList<>(); @@ -212,13 +298,26 @@ public static class MockHttp2SolrClient extends Http2SolrClient { public String tmpBaseUrl = null; - protected MockHttp2SolrClient(String serverBaseUrl, Builder builder) { + protected MockHttpSolrClient(String serverBaseUrl, Builder builder) { + // TODO: Consider creating an interface for Http*SolrClient // so mocks can Implement, not Extend, and not actually need to // build an (unused) client super(serverBaseUrl, builder); } + @Override + public NamedList request(final SolrRequest request, String collection) + throws SolrServerException, IOException { + lastSolrRequests.add(request); + lastBasePaths.add(tmpBaseUrl); + lastCollections.add(collection); + if (tmpBaseUrl.equals(basePathToFail)) { + throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "We should retry this."); + } + return generateResponse(request); + } + @Override public R requestWithBaseUrl( String baseUrl, SolrClientFunction clientFunction) diff --git a/solr/solrj/src/test/org/apache/solr/client/solrj/impl/MockTrustManager.java b/solr/solrj/src/test/org/apache/solr/client/solrj/impl/MockTrustManager.java new file mode 100644 index 00000000000..c7e1351d01d --- /dev/null +++ b/solr/solrj/src/test/org/apache/solr/client/solrj/impl/MockTrustManager.java @@ -0,0 +1,100 @@ +/* + * 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.client.solrj.impl; + +import java.net.Socket; +import java.security.cert.CertificateException; +import java.security.cert.X509Certificate; +import javax.net.ssl.KeyManagerFactory; +import javax.net.ssl.SSLContext; +import javax.net.ssl.SSLEngine; +import javax.net.ssl.TrustManager; +import javax.net.ssl.X509ExtendedTrustManager; +import org.apache.solr.SolrTestCaseJ4; +import org.apache.solr.util.SSLTestConfig; + +/** + * Taken from: https://www.baeldung.com/java-httpclient-ssl sec 4.1, 2024/02/12. This is an + * all-trusting Trust Manager. Works with self-signed certificates. + */ +public class MockTrustManager extends X509ExtendedTrustManager { + + public static final SSLContext ALL_TRUSTING_SSL_CONTEXT; + + private static final MockTrustManager INSTANCE = new MockTrustManager(); + + static { + try { + KeyManagerFactory keyManagerFactory = + KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm()); + SSLTestConfig stc = SolrTestCaseJ4.sslConfig; + keyManagerFactory.init(stc.defaultKeyStore(), stc.defaultKeyStorePassword().toCharArray()); + + SSLContext sslContext = SSLContext.getInstance("SSL"); + sslContext.init( + keyManagerFactory.getKeyManagers(), + new TrustManager[] {INSTANCE}, + stc.notSecureSecureRandom()); + ALL_TRUSTING_SSL_CONTEXT = sslContext; + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + private MockTrustManager() {} + + @Override + public void checkClientTrusted(X509Certificate[] chain, String authType, Socket socket) + throws CertificateException { + // no-op + } + + @Override + public void checkServerTrusted(X509Certificate[] chain, String authType, Socket socket) + throws CertificateException { + // no-op + } + + @Override + public void checkClientTrusted(X509Certificate[] chain, String authType, SSLEngine engine) + throws CertificateException { + // no-op + } + + @Override + public void checkServerTrusted(X509Certificate[] chain, String authType, SSLEngine engine) + throws CertificateException { + // no-op + } + + @Override + public java.security.cert.X509Certificate[] getAcceptedIssuers() { + return new java.security.cert.X509Certificate[0]; + } + + @Override + public void checkClientTrusted(X509Certificate[] chain, String authType) + throws CertificateException { + // no-op + } + + @Override + public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) + throws CertificateException { + // no-op + } +} From 5cc733b9fc60d4887df576aef340aa027ed2fc3e Mon Sep 17 00:00:00 2001 From: Bruno Roustant <33934988+bruno-roustant@users.noreply.github.com> Date: Tue, 19 Nov 2024 17:15:36 +0100 Subject: [PATCH 08/33] SOLR-17504: CoreContainer calls UpdateHandler.commit. (#2786) --- solr/CHANGES.txt | 2 + .../org/apache/solr/core/CoreContainer.java | 21 ++-- .../solr/update/CommitUpdateCommand.java | 32 ++++++ .../solr/update/DirectUpdateHandler2.java | 11 ++- .../solr/collection1/conf/solrconfig.xml | 2 +- .../DirectUpdateHandlerWithUpdateLogTest.java | 98 +++++++++++++++++++ 6 files changed, 147 insertions(+), 19 deletions(-) create mode 100644 solr/core/src/test/org/apache/solr/update/DirectUpdateHandlerWithUpdateLogTest.java diff --git a/solr/CHANGES.txt b/solr/CHANGES.txt index 05574f64371..80e4820ff25 100644 --- a/solr/CHANGES.txt +++ b/solr/CHANGES.txt @@ -167,6 +167,8 @@ Improvements * SOLR-17390: EmbeddedSolrServer now considers the ResponseParser (David Smiley) +* SOLR-17504: CoreContainer calls UpdateHandler.commit when closing a read-only core (Bruno Roustant) + Optimizations --------------------- * SOLR-14985: Solrj CloudSolrClient with Solr URLs had serious performance regressions (since the diff --git a/solr/core/src/java/org/apache/solr/core/CoreContainer.java b/solr/core/src/java/org/apache/solr/core/CoreContainer.java index a92c73ef496..69b6f07fb47 100644 --- a/solr/core/src/java/org/apache/solr/core/CoreContainer.java +++ b/solr/core/src/java/org/apache/solr/core/CoreContainer.java @@ -59,7 +59,6 @@ import org.apache.http.client.CredentialsProvider; import org.apache.http.config.Lookup; import org.apache.lucene.index.CorruptIndexException; -import org.apache.lucene.index.IndexWriter; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.store.Directory; import org.apache.lucene.util.BytesRef; @@ -95,6 +94,7 @@ import org.apache.solr.common.cloud.Replica.State; import org.apache.solr.common.cloud.SolrZkClient; import org.apache.solr.common.cloud.ZkStateReader; +import org.apache.solr.common.params.ModifiableSolrParams; import org.apache.solr.common.util.CollectionUtil; import org.apache.solr.common.util.ExecutorUtil; import org.apache.solr.common.util.IOUtils; @@ -138,6 +138,8 @@ import org.apache.solr.metrics.SolrMetricProducer; import org.apache.solr.metrics.SolrMetricsContext; import org.apache.solr.pkg.SolrPackageLoader; +import org.apache.solr.request.LocalSolrQueryRequest; +import org.apache.solr.request.SolrQueryRequest; import org.apache.solr.request.SolrRequestHandler; import org.apache.solr.request.SolrRequestInfo; import org.apache.solr.search.CacheConfig; @@ -153,10 +155,10 @@ import org.apache.solr.security.PublicKeyHandler; import org.apache.solr.security.SecurityPluginHolder; import org.apache.solr.security.SolrNodeKeyPair; +import org.apache.solr.update.CommitUpdateCommand; import org.apache.solr.update.SolrCoreState; import org.apache.solr.update.UpdateShardHandler; import org.apache.solr.util.OrderedExecutor; -import org.apache.solr.util.RefCounted; import org.apache.solr.util.StartupLoggingUtils; import org.apache.solr.util.stats.MetricUtils; import org.apache.zookeeper.KeeperException; @@ -2058,19 +2060,8 @@ public void reload(String name, UUID coreId) { // force commit on old core if the new one is readOnly and prevent any new updates if (newCore.readOnly) { - RefCounted iwRef = core.getSolrCoreState().getIndexWriter(null); - if (iwRef != null) { - IndexWriter iw = iwRef.get(); - // switch old core to readOnly - core.readOnly = true; - try { - if (iw != null) { - iw.commit(); - } - } finally { - iwRef.decref(); - } - } + SolrQueryRequest req = new LocalSolrQueryRequest(core, new ModifiableSolrParams()); + core.getUpdateHandler().commit(CommitUpdateCommand.closeOnCommit(req, false)); } if (docCollection != null) { diff --git a/solr/core/src/java/org/apache/solr/update/CommitUpdateCommand.java b/solr/core/src/java/org/apache/solr/update/CommitUpdateCommand.java index bb18b770e5d..6a749af2ac9 100644 --- a/solr/core/src/java/org/apache/solr/update/CommitUpdateCommand.java +++ b/solr/core/src/java/org/apache/solr/update/CommitUpdateCommand.java @@ -21,9 +21,21 @@ /** A commit index command encapsulated in an object. */ public class CommitUpdateCommand extends UpdateCommand { + + // Behavior about opening a searcher after a hard commit. + // - Open a standard searcher and wait for it. (default) + // openSearcher == true && waitSearcher == true && closeSearcher == false + // - Open a standard searcher, but do not wait for it. + // openSearcher == true && waitSearcher == false && closeSearcher == false + // - Open a real-time searcher quicker without auto-warming. + // openSearcher == false && closeSearcher == false + // - Do not open any searcher and prevent further updates (e.g. when the core is closing). + // closeSearcher == true + public boolean optimize; public boolean openSearcher = true; // open a new searcher as part of a hard commit public boolean waitSearcher = true; + private boolean closeSearcher = false; public boolean expungeDeletes = false; public boolean softCommit = false; public boolean prepareCommit = false; @@ -47,6 +59,26 @@ public CommitUpdateCommand(SolrQueryRequest req, boolean optimize) { this.optimize = optimize; } + /** + * Creates a {@link CommitUpdateCommand} to commit before closing the core and also prevent any + * new update by setting the core in read-only mode. Does not open a new searcher. + */ + public static CommitUpdateCommand closeOnCommit(SolrQueryRequest req, boolean optimize) { + CommitUpdateCommand cmd = new CommitUpdateCommand(req, optimize); + cmd.openSearcher = false; + cmd.waitSearcher = false; + cmd.closeSearcher = true; + return cmd; + } + + /** + * Indicates whether this command is a commit before the core is closed. Any new updates must be + * prevented after the commit. + */ + public boolean isClosingOnCommit() { + return closeSearcher; + } + @Override public String name() { return "commit"; diff --git a/solr/core/src/java/org/apache/solr/update/DirectUpdateHandler2.java b/solr/core/src/java/org/apache/solr/update/DirectUpdateHandler2.java index d730cc137fb..2704ef4e027 100644 --- a/solr/core/src/java/org/apache/solr/update/DirectUpdateHandler2.java +++ b/solr/core/src/java/org/apache/solr/update/DirectUpdateHandler2.java @@ -738,6 +738,9 @@ public void commit(CommitUpdateCommand cmd) throws IOException { RefCounted iw = solrCoreState.getIndexWriter(core); try { + if (cmd.isClosingOnCommit()) { + core.readOnly = true; + } IndexWriter writer = iw.get(); if (cmd.optimize) { writer.forceMerge(cmd.maxOptimizeSegments); @@ -786,7 +789,7 @@ public void commit(CommitUpdateCommand cmd) throws IOException { if (ulog != null) ulog.preSoftCommit(cmd); if (cmd.openSearcher) { core.getSearcher(true, false, waitSearcher); - } else { + } else if (!cmd.isClosingOnCommit()) { // force open a new realtime searcher so realtime-get and versioning code can see the // latest RefCounted searchHolder = core.openNewSearcher(true, true); @@ -971,8 +974,10 @@ public void closeWriter(IndexWriter writer) throws IOException { // todo: refactor this shared code (or figure out why a real CommitUpdateCommand can't // be used) - SolrIndexWriter.setCommitData(writer, cmd.getVersion(), null); - writer.commit(); + if (shouldCommit(cmd, writer)) { + SolrIndexWriter.setCommitData(writer, cmd.getVersion(), cmd.commitData); + writer.commit(); + } synchronized (solrCoreState.getUpdateLock()) { ulog.postCommit(cmd); diff --git a/solr/core/src/test-files/solr/collection1/conf/solrconfig.xml b/solr/core/src/test-files/solr/collection1/conf/solrconfig.xml index 2c06096732c..856079f329e 100644 --- a/solr/core/src/test-files/solr/collection1/conf/solrconfig.xml +++ b/solr/core/src/test-files/solr/collection1/conf/solrconfig.xml @@ -59,7 +59,7 @@ - + ${solr.autoCommit.maxTime:-1} diff --git a/solr/core/src/test/org/apache/solr/update/DirectUpdateHandlerWithUpdateLogTest.java b/solr/core/src/test/org/apache/solr/update/DirectUpdateHandlerWithUpdateLogTest.java new file mode 100644 index 00000000000..49a3be19697 --- /dev/null +++ b/solr/core/src/test/org/apache/solr/update/DirectUpdateHandlerWithUpdateLogTest.java @@ -0,0 +1,98 @@ +/* + * 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.update; + +import java.io.IOException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicInteger; +import org.apache.lucene.index.IndexWriter; +import org.apache.solr.SolrTestCaseJ4; +import org.apache.solr.common.util.TimeSource; +import org.apache.solr.core.SolrCore; +import org.apache.solr.util.LogLevel; +import org.apache.solr.util.TimeOut; +import org.junit.BeforeClass; +import org.junit.Test; + +/** Tests {@link DirectUpdateHandler2} with update log enabled. */ +@LogLevel("org.apache.solr.update=INFO") +public class DirectUpdateHandlerWithUpdateLogTest extends SolrTestCaseJ4 { + + @BeforeClass + public static void beforeClass() throws Exception { + System.setProperty("solr.updateHandler", SpyingUpdateHandler.class.getName()); + initCore("solrconfig.xml", "schema11.xml"); + } + + @Test + public void testShouldCommitHook() throws Exception { + // Given a core. + SolrCore core = h.getCore(); + assertNotNull(core); + SpyingUpdateHandler updater = (SpyingUpdateHandler) core.getUpdateHandler(); + updater.shouldCommitCallCount.set(0); + + // When we add a doc and commit. + assertU(adoc("id", "1")); + assertU(commit()); + // Then the shouldCommit hook is called. + assertEquals(1, updater.shouldCommitCallCount.get()); + + // When we add a doc and soft commit. + assertU(adoc("id", "2")); + assertU(commit("softCommit", "true")); + // Then the shouldCommit hook is not called. + assertEquals(1, updater.shouldCommitCallCount.get()); + // And when we commit. + assertU(commit()); + // Then the shouldCommit hook is called. + assertEquals(2, updater.shouldCommitCallCount.get()); + + // When we commit with no updates (empty commit). + assertU(commit()); + // Then the shouldCommit hook is called (may commit only user metadata). + assertEquals(3, updater.shouldCommitCallCount.get()); + + // When we add a doc, do not commit, and close the IndexWriter. + assertU(adoc("id", "3")); + h.close(); + // Then the shouldCommit hook is called. + new TimeOut(10, TimeUnit.SECONDS, TimeSource.NANO_TIME) + .waitFor( + "Timeout waiting for should commit hook", + () -> updater.shouldCommitCallCount.get() == 4); + } + + public static class SpyingUpdateHandler extends DirectUpdateHandler2 { + + final AtomicInteger shouldCommitCallCount = new AtomicInteger(); + + public SpyingUpdateHandler(SolrCore core) { + super(core); + } + + public SpyingUpdateHandler(SolrCore core, UpdateHandler updateHandler) { + super(core, updateHandler); + } + + @Override + protected boolean shouldCommit(CommitUpdateCommand cmd, IndexWriter writer) throws IOException { + shouldCommitCallCount.incrementAndGet(); + return super.shouldCommit(cmd, writer); + } + } +} From e1f56b30c33d9adfcb2c7aac1c01ef5393400c1e Mon Sep 17 00:00:00 2001 From: Christos Malliaridis Date: Tue, 19 Nov 2024 22:06:44 +0200 Subject: [PATCH 09/33] SOLR-17501: Move out CLI utils from SolrCLI (#2744) --- .../src/java/org/apache/solr/cli/ApiTool.java | 2 +- .../java/org/apache/solr/cli/AssertTool.java | 18 +- .../java/org/apache/solr/cli/AuthTool.java | 16 +- .../java/org/apache/solr/cli/CLIUtils.java | 351 ++++++++++++++++++ .../java/org/apache/solr/cli/ClusterTool.java | 2 +- .../org/apache/solr/cli/CommonCLIOptions.java | 2 +- .../solr/cli/ConfigSetDownloadTool.java | 4 +- .../apache/solr/cli/ConfigSetUploadTool.java | 6 +- .../java/org/apache/solr/cli/ConfigTool.java | 4 +- .../java/org/apache/solr/cli/CreateTool.java | 20 +- .../java/org/apache/solr/cli/DeleteTool.java | 8 +- .../java/org/apache/solr/cli/ExportTool.java | 4 +- .../org/apache/solr/cli/HealthcheckTool.java | 12 +- .../org/apache/solr/cli/LinkConfigTool.java | 2 +- .../java/org/apache/solr/cli/PackageTool.java | 6 +- .../org/apache/solr/cli/PostLogsTool.java | 2 +- .../java/org/apache/solr/cli/PostTool.java | 8 +- .../org/apache/solr/cli/RunExampleTool.java | 8 +- .../apache/solr/cli/SnapshotCreateTool.java | 2 +- .../apache/solr/cli/SnapshotDeleteTool.java | 2 +- .../apache/solr/cli/SnapshotDescribeTool.java | 2 +- .../apache/solr/cli/SnapshotExportTool.java | 2 +- .../org/apache/solr/cli/SnapshotListTool.java | 2 +- .../src/java/org/apache/solr/cli/SolrCLI.java | 296 +-------------- .../java/org/apache/solr/cli/StatusTool.java | 32 +- .../java/org/apache/solr/cli/StreamTool.java | 4 +- .../org/apache/solr/cli/UpdateACLTool.java | 2 +- .../java/org/apache/solr/cli/ZkCpTool.java | 2 +- .../java/org/apache/solr/cli/ZkLsTool.java | 4 +- .../org/apache/solr/cli/ZkMkrootTool.java | 4 +- .../java/org/apache/solr/cli/ZkMvTool.java | 4 +- .../java/org/apache/solr/cli/ZkRmTool.java | 4 +- .../solr/packagemanager/PackageManager.java | 5 +- .../solr/packagemanager/PackageUtils.java | 4 +- .../org/apache/solr/cli/CLIUtilsTest.java | 144 +++++++ .../test/org/apache/solr/cli/SolrCLITest.java | 9 - .../solr/cli/TestSolrCLIRunExample.java | 2 +- .../solr/cloud/SolrCloudExampleTest.java | 3 +- 38 files changed, 594 insertions(+), 410 deletions(-) create mode 100644 solr/core/src/java/org/apache/solr/cli/CLIUtils.java create mode 100644 solr/core/src/test/org/apache/solr/cli/CLIUtilsTest.java diff --git a/solr/core/src/java/org/apache/solr/cli/ApiTool.java b/solr/core/src/java/org/apache/solr/cli/ApiTool.java index 02f893b3753..ede4de68971 100644 --- a/solr/core/src/java/org/apache/solr/cli/ApiTool.java +++ b/solr/core/src/java/org/apache/solr/cli/ApiTool.java @@ -79,7 +79,7 @@ protected String callGet(String url, String credentials) throws Exception { URI uri = new URI(url.replace("+", "%20")); String solrUrl = getSolrUrlFromUri(uri); String path = uri.getPath(); - try (var solrClient = SolrCLI.getSolrClient(solrUrl, credentials)) { + try (var solrClient = CLIUtils.getSolrClient(solrUrl, credentials)) { // For path parameter we need the path without the root so from the second / char // (because root can be configured) // E.g URL is http://localhost:8983/solr/admin/info/system path is diff --git a/solr/core/src/java/org/apache/solr/cli/AssertTool.java b/solr/core/src/java/org/apache/solr/cli/AssertTool.java index b710d0934b2..b111ef7b481 100644 --- a/solr/core/src/java/org/apache/solr/cli/AssertTool.java +++ b/solr/core/src/java/org/apache/solr/cli/AssertTool.java @@ -250,13 +250,13 @@ protected int runAssert(CommandLine cli) throws Exception { if (cli.hasOption(IS_CLOUD_OPTION)) { ret += assertSolrRunningInCloudMode( - SolrCLI.normalizeSolrUrl(cli.getOptionValue(IS_CLOUD_OPTION)), + CLIUtils.normalizeSolrUrl(cli.getOptionValue(IS_CLOUD_OPTION)), cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION)); } if (cli.hasOption(IS_NOT_CLOUD_OPTION)) { ret += assertSolrNotRunningInCloudMode( - SolrCLI.normalizeSolrUrl(cli.getOptionValue(IS_NOT_CLOUD_OPTION)), + CLIUtils.normalizeSolrUrl(cli.getOptionValue(IS_NOT_CLOUD_OPTION)), cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION)); } return ret; @@ -267,7 +267,7 @@ public static int assertSolrRunning(String url, String credentials) throws Excep try { status.waitToSeeSolrUp(url, credentials, timeoutMs, TimeUnit.MILLISECONDS); } catch (Exception se) { - if (SolrCLI.exceptionIsAuthRelated(se)) { + if (CLIUtils.exceptionIsAuthRelated(se)) { throw se; } return exitOrException( @@ -284,10 +284,10 @@ public static int assertSolrNotRunning(String url, String credentials) throws Ex StatusTool status = new StatusTool(); long timeout = System.nanoTime() + TimeUnit.NANOSECONDS.convert(timeoutMs, TimeUnit.MILLISECONDS); - try (SolrClient solrClient = SolrCLI.getSolrClient(url, credentials)) { + try (SolrClient solrClient = CLIUtils.getSolrClient(url, credentials)) { NamedList response = solrClient.request(new HealthCheckRequest()); Integer statusCode = (Integer) response.findRecursive("responseHeader", "status"); - SolrCLI.checkCodeForAuthError(statusCode); + CLIUtils.checkCodeForAuthError(statusCode); } catch (IOException | SolrServerException e) { log.debug("Opening connection to {} failed, Solr does not seem to be running", url, e); return 0; @@ -302,7 +302,7 @@ public static int assertSolrNotRunning(String url, String credentials) throws Ex timeout = 0; // stop looping } } catch (Exception se) { - if (SolrCLI.exceptionIsAuthRelated(se)) { + if (CLIUtils.exceptionIsAuthRelated(se)) { throw se; } return exitOrException(se.getMessage()); @@ -417,7 +417,7 @@ private static boolean isSolrRunningOn(String url, String credentials) throws Ex status.waitToSeeSolrUp(url, credentials, timeoutMs, TimeUnit.MILLISECONDS); return true; } catch (Exception se) { - if (SolrCLI.exceptionIsAuthRelated(se)) { + if (CLIUtils.exceptionIsAuthRelated(se)) { throw se; } return false; @@ -425,8 +425,8 @@ private static boolean isSolrRunningOn(String url, String credentials) throws Ex } private static boolean runningSolrIsCloud(String url, String credentials) throws Exception { - try (final SolrClient client = SolrCLI.getSolrClient(url, credentials)) { - return SolrCLI.isCloudMode(client); + try (final SolrClient client = CLIUtils.getSolrClient(url, credentials)) { + return CLIUtils.isCloudMode(client); } } diff --git a/solr/core/src/java/org/apache/solr/cli/AuthTool.java b/solr/core/src/java/org/apache/solr/cli/AuthTool.java index 817b0093748..45b609a2943 100644 --- a/solr/core/src/java/org/apache/solr/cli/AuthTool.java +++ b/solr/core/src/java/org/apache/solr/cli/AuthTool.java @@ -194,7 +194,7 @@ private void handleKerberos(CommandLine cli) throws Exception { if (!updateIncludeFileOnly) { try { - zkHost = SolrCLI.getZkHost(cli); + zkHost = CLIUtils.getZkHost(cli); } catch (Exception ex) { CLIO.out( "Unable to access ZooKeeper. Please add the following security.json to ZooKeeper (in case of SolrCloud):\n" @@ -214,7 +214,7 @@ private void handleKerberos(CommandLine cli) throws Exception { // check if security is already enabled or not if (!zkInaccessible) { - try (SolrZkClient zkClient = SolrCLI.getSolrZkClient(cli, zkHost)) { + try (SolrZkClient zkClient = CLIUtils.getSolrZkClient(cli, zkHost)) { checkSecurityJsonExists(zkClient); } catch (Exception ex) { CLIO.out( @@ -229,7 +229,7 @@ private void handleKerberos(CommandLine cli) throws Exception { if (!updateIncludeFileOnly) { if (!zkInaccessible) { echoIfVerbose("Uploading following security.json: " + securityJson); - try (SolrZkClient zkClient = SolrCLI.getSolrZkClient(cli, zkHost)) { + try (SolrZkClient zkClient = CLIUtils.getSolrZkClient(cli, zkHost)) { zkClient.setData( "/security.json", securityJson.getBytes(StandardCharsets.UTF_8), true); } catch (Exception ex) { @@ -309,7 +309,7 @@ private void handleBasicAuth(CommandLine cli) throws Exception { if (!updateIncludeFileOnly) { try { - zkHost = SolrCLI.getZkHost(cli); + zkHost = CLIUtils.getZkHost(cli); } catch (Exception ex) { if (cli.hasOption(CommonCLIOptions.ZK_HOST_OPTION)) { CLIO.out( @@ -332,7 +332,7 @@ private void handleBasicAuth(CommandLine cli) throws Exception { } // check if security is already enabled or not - try (SolrZkClient zkClient = SolrCLI.getSolrZkClient(cli, zkHost)) { + try (SolrZkClient zkClient = CLIUtils.getSolrZkClient(cli, zkHost)) { checkSecurityJsonExists(zkClient); } } @@ -381,7 +381,7 @@ private void handleBasicAuth(CommandLine cli) throws Exception { if (!updateIncludeFileOnly) { echoIfVerbose("Uploading following security.json: " + securityJson); - try (SolrZkClient zkClient = SolrCLI.getSolrZkClient(cli, zkHost)) { + try (SolrZkClient zkClient = CLIUtils.getSolrZkClient(cli, zkHost)) { zkClient.setData("/security.json", securityJson.getBytes(StandardCharsets.UTF_8), true); } } @@ -460,7 +460,7 @@ private void checkSecurityJsonExists(SolrZkClient zkClient) private void clearSecurityJson(CommandLine cli, boolean updateIncludeFileOnly) throws Exception { String zkHost; if (!updateIncludeFileOnly) { - zkHost = SolrCLI.getZkHost(cli); + zkHost = CLIUtils.getZkHost(cli); if (zkHost == null) { stdout.print("ZK Host not found. Solr should be running in cloud mode."); SolrCLI.exit(1); @@ -468,7 +468,7 @@ private void clearSecurityJson(CommandLine cli, boolean updateIncludeFileOnly) t echoIfVerbose("Uploading following security.json: {}"); - try (SolrZkClient zkClient = SolrCLI.getSolrZkClient(cli, zkHost)) { + try (SolrZkClient zkClient = CLIUtils.getSolrZkClient(cli, zkHost)) { zkClient.setData("/security.json", "{}".getBytes(StandardCharsets.UTF_8), true); } } diff --git a/solr/core/src/java/org/apache/solr/cli/CLIUtils.java b/solr/core/src/java/org/apache/solr/cli/CLIUtils.java new file mode 100644 index 00000000000..7f4c0dc648b --- /dev/null +++ b/solr/core/src/java/org/apache/solr/cli/CLIUtils.java @@ -0,0 +1,351 @@ +/* + * 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.cli; + +import static org.apache.solr.common.SolrException.ErrorCode.FORBIDDEN; +import static org.apache.solr.common.SolrException.ErrorCode.UNAUTHORIZED; +import static org.apache.solr.common.params.CommonParams.NAME; +import static org.apache.solr.common.params.CommonParams.SYSTEM_INFO_PATH; + +import java.io.IOException; +import java.net.SocketException; +import java.net.URI; +import java.net.URISyntaxException; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.TimeUnit; +import org.apache.commons.cli.CommandLine; +import org.apache.solr.client.solrj.SolrClient; +import org.apache.solr.client.solrj.SolrRequest; +import org.apache.solr.client.solrj.SolrServerException; +import org.apache.solr.client.solrj.impl.CloudHttp2SolrClient; +import org.apache.solr.client.solrj.impl.CloudSolrClient; +import org.apache.solr.client.solrj.impl.Http2SolrClient; +import org.apache.solr.client.solrj.impl.SolrZkClientTimeout; +import org.apache.solr.client.solrj.request.CollectionAdminRequest; +import org.apache.solr.client.solrj.request.CoreAdminRequest; +import org.apache.solr.client.solrj.request.GenericSolrRequest; +import org.apache.solr.common.SolrException; +import org.apache.solr.common.cloud.SolrZkClient; +import org.apache.solr.common.cloud.ZkStateReader; +import org.apache.solr.common.params.CommonParams; +import org.apache.solr.common.util.EnvUtils; +import org.apache.solr.common.util.NamedList; + +/** Utility class that holds various helper methods for the CLI. */ +public final class CLIUtils { + + private CLIUtils() {} + + public static String RED = "\u001B[31m"; + + public static String GREEN = "\u001B[32m"; + + public static String YELLOW = "\u001B[33m"; + + private static final long MAX_WAIT_FOR_CORE_LOAD_NANOS = + TimeUnit.NANOSECONDS.convert(1, TimeUnit.MINUTES); + + public static String getDefaultSolrUrl() { + // note that ENV_VAR syntax (and the env vars too) are mapped to env.var sys props + String scheme = EnvUtils.getProperty("solr.url.scheme", "http"); + String host = EnvUtils.getProperty("solr.tool.host", "localhost"); + String port = EnvUtils.getProperty("jetty.port", "8983"); // from SOLR_PORT env + return String.format(Locale.ROOT, "%s://%s:%s", scheme.toLowerCase(Locale.ROOT), host, port); + } + + /** + * Determine if a request to Solr failed due to a communication error, which is generally + * retry-able. + */ + public static boolean checkCommunicationError(Exception exc) { + Throwable rootCause = SolrException.getRootCause(exc); + return (rootCause instanceof SolrServerException || rootCause instanceof SocketException); + } + + public static void checkCodeForAuthError(int code) { + if (code == UNAUTHORIZED.code || code == FORBIDDEN.code) { + throw new SolrException( + SolrException.ErrorCode.getErrorCode(code), + "Solr requires authentication for request. Please supply valid credentials. HTTP code=" + + code); + } + } + + public static boolean exceptionIsAuthRelated(Exception exc) { + return (exc instanceof SolrException + && Arrays.asList(UNAUTHORIZED.code, FORBIDDEN.code).contains(((SolrException) exc).code())); + } + + public static SolrClient getSolrClient(String solrUrl, String credentials, boolean barePath) { + // today we require all urls to end in /solr, however in the future we will need to support the + // /api url end point instead. Eventually we want to have this method always + // return a bare url, and then individual calls decide if they are /solr or /api + // The /solr/ check is because sometimes a full url is passed in, like + // http://localhost:8983/solr/films_shard1_replica_n1/. + if (!barePath && !solrUrl.endsWith("/solr") && !solrUrl.contains("/solr/")) { + solrUrl = solrUrl + "/solr"; + } + Http2SolrClient.Builder builder = + new Http2SolrClient.Builder(solrUrl) + .withMaxConnectionsPerHost(32) + .withKeyStoreReloadInterval(-1, TimeUnit.SECONDS) + .withOptionalBasicAuthCredentials(credentials); + + return builder.build(); + } + + /** + * Helper method for all the places where we assume a /solr on the url. + * + * @param solrUrl The solr url that you want the client for + * @param credentials The username:password for basic auth. + * @return The SolrClient + */ + public static SolrClient getSolrClient(String solrUrl, String credentials) { + return getSolrClient(solrUrl, credentials, false); + } + + public static SolrClient getSolrClient(CommandLine cli, boolean barePath) throws Exception { + String solrUrl = normalizeSolrUrl(cli); + String credentials = cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION); + return getSolrClient(solrUrl, credentials, barePath); + } + + public static SolrClient getSolrClient(CommandLine cli) throws Exception { + String solrUrl = normalizeSolrUrl(cli); + String credentials = cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION); + return getSolrClient(solrUrl, credentials, false); + } + + /** + * Strips off the end of solrUrl any /solr when a legacy solrUrl like http://localhost:8983/solr + * is used, and warns those users. In the future we'll have urls ending with /api as well. + * + * @param solrUrl The user supplied url to Solr. + * @return the solrUrl in the format that Solr expects to see internally. + */ + public static String normalizeSolrUrl(String solrUrl) { + return normalizeSolrUrl(solrUrl, true); + } + + /** + * Strips off the end of solrUrl any /solr when a legacy solrUrl like http://localhost:8983/solr + * is used, and optionally logs a warning. In the future we'll have urls ending with /api as well. + * + * @param solrUrl The user supplied url to Solr. + * @param logUrlFormatWarning If a warning message should be logged about the url format + * @return the solrUrl in the format that Solr expects to see internally. + */ + public static String normalizeSolrUrl(String solrUrl, boolean logUrlFormatWarning) { + if (solrUrl != null) { + URI uri = URI.create(solrUrl); + String urlPath = uri.getRawPath(); + if (urlPath != null && urlPath.contains("/solr")) { + String newSolrUrl = + uri.resolve(urlPath.substring(0, urlPath.lastIndexOf("/solr") + 1)).toString(); + if (logUrlFormatWarning) { + CLIO.err( + "WARNING: URLs provided to this tool needn't include Solr's context-root (e.g. \"/solr\"). Such URLs are deprecated and support for them will be removed in a future release. Correcting from [" + + solrUrl + + "] to [" + + newSolrUrl + + "]."); + } + solrUrl = newSolrUrl; + } + if (solrUrl.endsWith("/")) { + solrUrl = solrUrl.substring(0, solrUrl.length() - 1); + } + } + return solrUrl; + } + + /** + * Get the base URL of a live Solr instance from either the --solr-url command-line option or from + * ZooKeeper. + */ + public static String normalizeSolrUrl(CommandLine cli) throws Exception { + String solrUrl = cli.getOptionValue(CommonCLIOptions.SOLR_URL_OPTION); + + if (solrUrl == null) { + String zkHost = cli.getOptionValue(CommonCLIOptions.ZK_HOST_OPTION); + if (zkHost == null) { + solrUrl = getDefaultSolrUrl(); + CLIO.err( + "Neither --zk-host or --solr-url parameters provided so assuming solr url is " + + solrUrl + + "."); + } else { + try (CloudSolrClient cloudSolrClient = getCloudHttp2SolrClient(zkHost)) { + cloudSolrClient.connect(); + Set liveNodes = cloudSolrClient.getClusterState().getLiveNodes(); + if (liveNodes.isEmpty()) + throw new IllegalStateException( + "No live nodes found! Cannot determine 'solrUrl' from ZooKeeper: " + zkHost); + + String firstLiveNode = liveNodes.iterator().next(); + solrUrl = ZkStateReader.from(cloudSolrClient).getBaseUrlForNodeName(firstLiveNode); + solrUrl = normalizeSolrUrl(solrUrl, false); + } + } + } + solrUrl = normalizeSolrUrl(solrUrl); + return solrUrl; + } + + /** + * Get the ZooKeeper connection string from either the zk-host command-line option or by looking + * it up from a running Solr instance based on the solr-url option. + */ + public static String getZkHost(CommandLine cli) throws Exception { + + String zkHost = cli.getOptionValue(CommonCLIOptions.ZK_HOST_OPTION); + if (zkHost != null && !zkHost.isBlank()) { + return zkHost; + } + + try (SolrClient solrClient = getSolrClient(cli)) { + // hit Solr to get system info + NamedList systemInfo = + solrClient.request( + new GenericSolrRequest(SolrRequest.METHOD.GET, CommonParams.SYSTEM_INFO_PATH)); + + // convert raw JSON into user-friendly output + StatusTool statusTool = new StatusTool(); + Map status = statusTool.reportStatus(systemInfo, solrClient); + @SuppressWarnings("unchecked") + Map cloud = (Map) status.get("cloud"); + if (cloud != null) { + String zookeeper = (String) cloud.get("ZooKeeper"); + if (zookeeper.endsWith("(embedded)")) { + zookeeper = zookeeper.substring(0, zookeeper.length() - "(embedded)".length()); + } + zkHost = zookeeper; + } + } + + return zkHost; + } + + public static SolrZkClient getSolrZkClient(CommandLine cli, String zkHost) throws Exception { + if (zkHost == null) { + throw new IllegalStateException( + "Solr at " + + cli.getOptionValue(CommonCLIOptions.SOLR_URL_OPTION) + + " is running in standalone server mode, this command can only be used when running in SolrCloud mode.\n"); + } + return new SolrZkClient.Builder() + .withUrl(zkHost) + .withTimeout(SolrZkClientTimeout.DEFAULT_ZK_CLIENT_TIMEOUT, TimeUnit.MILLISECONDS) + .build(); + } + + public static CloudHttp2SolrClient getCloudHttp2SolrClient(String zkHost) { + return getCloudHttp2SolrClient(zkHost, null); + } + + public static CloudHttp2SolrClient getCloudHttp2SolrClient( + String zkHost, Http2SolrClient.Builder builder) { + return new CloudHttp2SolrClient.Builder(Collections.singletonList(zkHost), Optional.empty()) + .withInternalClientBuilder(builder) + .build(); + } + + /** + * Extracts the port from the provided {@code solrUrl}. If a URL is provided with https scheme and + * not explicitly defines the port, the default port for HTTPS (443) is used. + * + *

If URL does not contain a port nor https as scheme, it falls back to port 80. + * + * @param solrUrl the URL to extract the port from + * @return The port that was found. + * @throws NullPointerException If solrUrl is null + * @throws URISyntaxException If the given string violates RFC 2396, as augmented by the above + * deviations + */ + public static int portFromUrl(String solrUrl) throws URISyntaxException { + URI uri = new URI(solrUrl); + int port = uri.getPort(); + if (port == -1) { + return uri.getScheme().equals("https") ? 443 : 80; + } else { + return port; + } + } + + public static boolean safeCheckCollectionExists( + String solrUrl, String collection, String credentials) { + boolean exists = false; + try (var solrClient = getSolrClient(solrUrl, credentials)) { + NamedList existsCheckResult = solrClient.request(new CollectionAdminRequest.List()); + @SuppressWarnings("unchecked") + List collections = (List) existsCheckResult.get("collections"); + exists = collections != null && collections.contains(collection); + } catch (Exception exc) { + // just ignore it since we're only interested in a positive result here + } + return exists; + } + + @SuppressWarnings("unchecked") + public static boolean safeCheckCoreExists(String solrUrl, String coreName, String credentials) { + boolean exists = false; + try (var solrClient = getSolrClient(solrUrl, credentials)) { + boolean wait = false; + final long startWaitAt = System.nanoTime(); + do { + if (wait) { + final int clamPeriodForStatusPollMs = 1000; + Thread.sleep(clamPeriodForStatusPollMs); + } + NamedList existsCheckResult = + CoreAdminRequest.getStatus(coreName, solrClient).getResponse(); + NamedList status = (NamedList) existsCheckResult.get("status"); + NamedList coreStatus = (NamedList) status.get(coreName); + Map failureStatus = + (Map) existsCheckResult.get("initFailures"); + String errorMsg = (String) failureStatus.get(coreName); + final boolean hasName = coreStatus != null && coreStatus.asMap().containsKey(NAME); + exists = hasName || errorMsg != null; + wait = hasName && errorMsg == null && "true".equals(coreStatus.get("isLoading")); + } while (wait && System.nanoTime() - startWaitAt < MAX_WAIT_FOR_CORE_LOAD_NANOS); + } catch (Exception exc) { + // just ignore it since we're only interested in a positive result here + } + return exists; + } + + public static boolean isCloudMode(SolrClient solrClient) throws SolrServerException, IOException { + NamedList systemInfo = + solrClient.request(new GenericSolrRequest(SolrRequest.METHOD.GET, SYSTEM_INFO_PATH)); + return "solrcloud".equals(systemInfo.get("mode")); + } + + public static Path getConfigSetsDir(Path solrInstallDir) { + Path configSetsPath = Paths.get("server/solr/configsets/"); + return solrInstallDir.resolve(configSetsPath); + } +} diff --git a/solr/core/src/java/org/apache/solr/cli/ClusterTool.java b/solr/core/src/java/org/apache/solr/cli/ClusterTool.java index 1c71b7b8fee..714654829cc 100644 --- a/solr/core/src/java/org/apache/solr/cli/ClusterTool.java +++ b/solr/core/src/java/org/apache/solr/cli/ClusterTool.java @@ -79,7 +79,7 @@ public void runImpl(CommandLine cli) throws Exception { String propertyName = cli.getOptionValue(PROPERTY_OPTION); String propertyValue = cli.getOptionValue(VALUE_OPTION); - String zkHost = SolrCLI.getZkHost(cli); + String zkHost = CLIUtils.getZkHost(cli); if (!ZkController.checkChrootPath(zkHost, true)) { throw new IllegalStateException( diff --git a/solr/core/src/java/org/apache/solr/cli/CommonCLIOptions.java b/solr/core/src/java/org/apache/solr/cli/CommonCLIOptions.java index 93f02c3e359..e6425abe1f3 100644 --- a/solr/core/src/java/org/apache/solr/cli/CommonCLIOptions.java +++ b/solr/core/src/java/org/apache/solr/cli/CommonCLIOptions.java @@ -47,7 +47,7 @@ private CommonCLIOptions() {} .argName("HOST") .desc( "Base Solr URL, which can be used to determine the zk-host if that's not known; defaults to: " - + SolrCLI.getDefaultSolrUrl() + + CLIUtils.getDefaultSolrUrl() + '.') .build(); diff --git a/solr/core/src/java/org/apache/solr/cli/ConfigSetDownloadTool.java b/solr/core/src/java/org/apache/solr/cli/ConfigSetDownloadTool.java index b55b939117b..264023640f7 100644 --- a/solr/core/src/java/org/apache/solr/cli/ConfigSetDownloadTool.java +++ b/solr/core/src/java/org/apache/solr/cli/ConfigSetDownloadTool.java @@ -79,13 +79,13 @@ public String getUsage() { @Override public void runImpl(CommandLine cli) throws Exception { - String zkHost = SolrCLI.getZkHost(cli); + String zkHost = CLIUtils.getZkHost(cli); String confName = cli.getOptionValue(CONF_NAME_OPTION); String confDir = cli.getOptionValue(CONF_DIR_OPTION); echoIfVerbose("\nConnecting to ZooKeeper at " + zkHost + " ..."); - try (SolrZkClient zkClient = SolrCLI.getSolrZkClient(cli, zkHost)) { + try (SolrZkClient zkClient = CLIUtils.getSolrZkClient(cli, zkHost)) { Path configSetPath = Paths.get(confDir); // we try to be nice about having the "conf" in the directory, and we create it if it's not // there. diff --git a/solr/core/src/java/org/apache/solr/cli/ConfigSetUploadTool.java b/solr/core/src/java/org/apache/solr/cli/ConfigSetUploadTool.java index b959245af2e..a9fc0631e11 100644 --- a/solr/core/src/java/org/apache/solr/cli/ConfigSetUploadTool.java +++ b/solr/core/src/java/org/apache/solr/cli/ConfigSetUploadTool.java @@ -81,7 +81,7 @@ public String getUsage() { @Override public void runImpl(CommandLine cli) throws Exception { - String zkHost = SolrCLI.getZkHost(cli); + String zkHost = CLIUtils.getZkHost(cli); final String solrInstallDir = System.getProperty("solr.install.dir"); Path solrInstallDirPath = Paths.get(solrInstallDir); @@ -90,8 +90,8 @@ public void runImpl(CommandLine cli) throws Exception { String confDir = cli.getOptionValue(CONF_DIR_OPTION); echoIfVerbose("\nConnecting to ZooKeeper at " + zkHost + " ..."); - try (SolrZkClient zkClient = SolrCLI.getSolrZkClient(cli, zkHost)) { - final Path configsetsDirPath = SolrCLI.getConfigSetsDir(solrInstallDirPath); + try (SolrZkClient zkClient = CLIUtils.getSolrZkClient(cli, zkHost)) { + final Path configsetsDirPath = CLIUtils.getConfigSetsDir(solrInstallDirPath); Path confPath = ConfigSetService.getConfigsetPath(confDir, configsetsDirPath.toString()); echo( diff --git a/solr/core/src/java/org/apache/solr/cli/ConfigTool.java b/solr/core/src/java/org/apache/solr/cli/ConfigTool.java index fdd18f24d4b..e5e7c96791c 100644 --- a/solr/core/src/java/org/apache/solr/cli/ConfigTool.java +++ b/solr/core/src/java/org/apache/solr/cli/ConfigTool.java @@ -98,7 +98,7 @@ public Options getOptions() { @Override public void runImpl(CommandLine cli) throws Exception { - String solrUrl = SolrCLI.normalizeSolrUrl(cli); + String solrUrl = CLIUtils.normalizeSolrUrl(cli); String action = cli.getOptionValue(ACTION_OPTION, "set-property"); String collection = cli.getOptionValue(COLLECTION_NAME_OPTION); String property = cli.getOptionValue(PROPERTY_OPTION); @@ -127,7 +127,7 @@ public void runImpl(CommandLine cli) throws Exception { echoIfVerbose(jsonBody); try (SolrClient solrClient = - SolrCLI.getSolrClient(solrUrl, cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION))) { + CLIUtils.getSolrClient(solrUrl, cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION))) { NamedList result = SolrCLI.postJsonToSolr(solrClient, updatePath, jsonBody); Integer statusCode = (Integer) result.findRecursive("responseHeader", "status"); if (statusCode == 0) { diff --git a/solr/core/src/java/org/apache/solr/cli/CreateTool.java b/solr/core/src/java/org/apache/solr/cli/CreateTool.java index 5fc57501d93..b1607af071b 100644 --- a/solr/core/src/java/org/apache/solr/cli/CreateTool.java +++ b/solr/core/src/java/org/apache/solr/cli/CreateTool.java @@ -138,8 +138,8 @@ public Options getOptions() { @Override public void runImpl(CommandLine cli) throws Exception { - try (var solrClient = SolrCLI.getSolrClient(cli)) { - if (SolrCLI.isCloudMode(solrClient)) { + try (var solrClient = CLIUtils.getSolrClient(cli)) { + if (CLIUtils.isCloudMode(solrClient)) { createCollection(cli); } else { createCore(cli, solrClient); @@ -150,7 +150,7 @@ public void runImpl(CommandLine cli) throws Exception { protected void createCore(CommandLine cli, SolrClient solrClient) throws Exception { String coreName = cli.getOptionValue(COLLECTION_NAME_OPTION); String solrUrl = - cli.getOptionValue(CommonCLIOptions.SOLR_URL_OPTION, SolrCLI.getDefaultSolrUrl()); + cli.getOptionValue(CommonCLIOptions.SOLR_URL_OPTION, CLIUtils.getDefaultSolrUrl()); final String solrInstallDir = System.getProperty("solr.install.dir"); final String confDirName = @@ -175,7 +175,7 @@ protected void createCore(CommandLine cli, SolrClient solrClient) throws Excepti // convert raw JSON into user-friendly output coreRootDirectory = (String) systemInfo.get("core_root"); - if (SolrCLI.safeCheckCoreExists( + if (CLIUtils.safeCheckCoreExists( solrUrl, coreName, cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION))) { throw new IllegalArgumentException( "\nCore '" @@ -224,9 +224,9 @@ protected void createCollection(CommandLine cli) throws Exception { .withKeyStoreReloadInterval(-1, TimeUnit.SECONDS) .withOptionalBasicAuthCredentials( cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION)); - String zkHost = SolrCLI.getZkHost(cli); + String zkHost = CLIUtils.getZkHost(cli); echoIfVerbose("Connecting to ZooKeeper at " + zkHost); - try (CloudSolrClient cloudSolrClient = SolrCLI.getCloudHttp2SolrClient(zkHost, builder)) { + try (CloudSolrClient cloudSolrClient = CLIUtils.getCloudHttp2SolrClient(zkHost, builder)) { cloudSolrClient.connect(); createCollection(cloudSolrClient, cli); } @@ -277,7 +277,7 @@ protected void createCollection(CloudSolrClient cloudSolrClient, CommandLine cli } // TODO: This should be done using the configSet API - final Path configsetsDirPath = SolrCLI.getConfigSetsDir(solrInstallDirPath); + final Path configsetsDirPath = CLIUtils.getConfigSetsDir(solrInstallDirPath); ConfigSetService configSetService = new ZkConfigSetService(ZkStateReader.from(cloudSolrClient).getZkClient()); Path confPath = ConfigSetService.getConfigsetPath(confDir, configsetsDirPath.toString()); @@ -294,7 +294,7 @@ protected void createCollection(CloudSolrClient cloudSolrClient, CommandLine cli } // since creating a collection is a heavy-weight operation, check for existence first - if (SolrCLI.safeCheckCollectionExists( + if (CLIUtils.safeCheckCollectionExists( solrUrl, collectionName, cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION))) { throw new IllegalStateException( "\nCollection '" @@ -339,7 +339,7 @@ protected void createCollection(CloudSolrClient cloudSolrClient, CommandLine cli } private Path getFullConfDir(Path solrInstallDir, Path confDirName) { - return SolrCLI.getConfigSetsDir(solrInstallDir).resolve(confDirName); + return CLIUtils.getConfigSetsDir(solrInstallDir).resolve(confDirName); } private void ensureConfDirExists(Path solrInstallDir, Path confDirName) { @@ -362,7 +362,7 @@ private void printDefaultConfigsetWarningIfNecessary(CommandLine cli) { && (confName.equals("") || confName.equals("_default"))) { final String collectionName = cli.getOptionValue(COLLECTION_NAME_OPTION); final String solrUrl = - cli.getOptionValue(CommonCLIOptions.SOLR_URL_OPTION, SolrCLI.getDefaultSolrUrl()); + cli.getOptionValue(CommonCLIOptions.SOLR_URL_OPTION, CLIUtils.getDefaultSolrUrl()); final String curlCommand = String.format( Locale.ROOT, diff --git a/solr/core/src/java/org/apache/solr/cli/DeleteTool.java b/solr/core/src/java/org/apache/solr/cli/DeleteTool.java index 2c42f8dc030..7fc94cb85d3 100644 --- a/solr/core/src/java/org/apache/solr/cli/DeleteTool.java +++ b/solr/core/src/java/org/apache/solr/cli/DeleteTool.java @@ -101,8 +101,8 @@ public Options getOptions() { @Override public void runImpl(CommandLine cli) throws Exception { - try (var solrClient = SolrCLI.getSolrClient(cli)) { - if (SolrCLI.isCloudMode(solrClient)) { + try (var solrClient = CLIUtils.getSolrClient(cli)) { + if (CLIUtils.isCloudMode(solrClient)) { deleteCollection(cli); } else { deleteCore(cli, solrClient); @@ -119,8 +119,8 @@ protected void deleteCollection(CommandLine cli) throws Exception { .withOptionalBasicAuthCredentials( cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION)); - String zkHost = SolrCLI.getZkHost(cli); - try (CloudSolrClient cloudSolrClient = SolrCLI.getCloudHttp2SolrClient(zkHost, builder)) { + String zkHost = CLIUtils.getZkHost(cli); + try (CloudSolrClient cloudSolrClient = CLIUtils.getCloudHttp2SolrClient(zkHost, builder)) { echoIfVerbose("Connecting to ZooKeeper at " + zkHost); cloudSolrClient.connect(); deleteCollection(cloudSolrClient, cli); diff --git a/solr/core/src/java/org/apache/solr/cli/ExportTool.java b/solr/core/src/java/org/apache/solr/cli/ExportTool.java index 5018855e597..ee8e5a42c78 100644 --- a/solr/core/src/java/org/apache/solr/cli/ExportTool.java +++ b/solr/core/src/java/org/apache/solr/cli/ExportTool.java @@ -284,7 +284,7 @@ public void runImpl(CommandLine cli) throws Exception { throw new IllegalArgumentException( "Must specify -c / --name parameter with --solr-url to post documents."); } - url = SolrCLI.normalizeSolrUrl(cli) + "/solr/" + cli.getOptionValue(COLLECTION_NAME_OPTION); + url = CLIUtils.normalizeSolrUrl(cli) + "/solr/" + cli.getOptionValue(COLLECTION_NAME_OPTION); } else { // think about support --zk-host someday. @@ -664,7 +664,7 @@ class CoreHandler { boolean exportDocsFromCore() throws IOException, SolrServerException { - try (SolrClient client = SolrCLI.getSolrClient(baseurl, credentials)) { + try (SolrClient client = CLIUtils.getSolrClient(baseurl, credentials)) { expectedDocs = getDocCount(replica.getCoreName(), client, query); QueryRequest request; ModifiableSolrParams params = new ModifiableSolrParams(); diff --git a/solr/core/src/java/org/apache/solr/cli/HealthcheckTool.java b/solr/core/src/java/org/apache/solr/cli/HealthcheckTool.java index 6ec08f77d6c..8a6b293e17a 100644 --- a/solr/core/src/java/org/apache/solr/cli/HealthcheckTool.java +++ b/solr/core/src/java/org/apache/solr/cli/HealthcheckTool.java @@ -89,12 +89,12 @@ public HealthcheckTool(PrintStream stdout) { @Override public void runImpl(CommandLine cli) throws Exception { - String zkHost = SolrCLI.getZkHost(cli); + String zkHost = CLIUtils.getZkHost(cli); if (zkHost == null) { CLIO.err("Healthcheck tool only works in Solr Cloud mode."); System.exit(1); } - try (CloudHttp2SolrClient cloudSolrClient = SolrCLI.getCloudHttp2SolrClient(zkHost)) { + try (CloudHttp2SolrClient cloudSolrClient = CLIUtils.getCloudHttp2SolrClient(zkHost)) { echoIfVerbose("\nConnecting to ZooKeeper at " + zkHost + " ..."); cloudSolrClient.connect(); runCloudTool(cloudSolrClient, cli); @@ -125,7 +125,7 @@ protected void runCloudTool(CloudSolrClient cloudSolrClient, CommandLine cli) th SolrQuery q = new SolrQuery("*:*"); q.setRows(0); QueryResponse qr = cloudSolrClient.query(collection, q); - SolrCLI.checkCodeForAuthError(qr.getStatus()); + CLIUtils.checkCodeForAuthError(qr.getStatus()); String collErr = null; long docCount = -1; try { @@ -169,12 +169,12 @@ protected void runCloudTool(CloudSolrClient cloudSolrClient, CommandLine cli) th q.setRows(0); q.set(DISTRIB, "false"); try (var solrClientForCollection = - SolrCLI.getSolrClient( + CLIUtils.getSolrClient( coreUrl, cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION))) { qr = solrClientForCollection.query(q); numDocs = qr.getResults().getNumFound(); try (var solrClient = - SolrCLI.getSolrClient( + CLIUtils.getSolrClient( replicaCoreProps.getBaseUrl(), cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION))) { NamedList systemInfo = @@ -192,7 +192,7 @@ protected void runCloudTool(CloudSolrClient cloudSolrClient, CommandLine cli) th } catch (Exception exc) { log.error("ERROR: {} when trying to reach: {}", exc, coreUrl); - if (SolrCLI.checkCommunicationError(exc)) { + if (CLIUtils.checkCommunicationError(exc)) { replicaStatus = Replica.State.DOWN.toString(); } else { replicaStatus = "error: " + exc; diff --git a/solr/core/src/java/org/apache/solr/cli/LinkConfigTool.java b/solr/core/src/java/org/apache/solr/cli/LinkConfigTool.java index 2261b96474d..619e1d82e5c 100644 --- a/solr/core/src/java/org/apache/solr/cli/LinkConfigTool.java +++ b/solr/core/src/java/org/apache/solr/cli/LinkConfigTool.java @@ -78,7 +78,7 @@ public void runImpl(CommandLine cli) throws Exception { String collection = cli.getOptionValue(COLLECTION_NAME_OPTION); String confName = cli.getOptionValue(CONF_NAME_OPTION); - String zkHost = SolrCLI.getZkHost(cli); + String zkHost = CLIUtils.getZkHost(cli); try (SolrZkClient zkClient = new SolrZkClient.Builder() diff --git a/solr/core/src/java/org/apache/solr/cli/PackageTool.java b/solr/core/src/java/org/apache/solr/cli/PackageTool.java index cb8bc6493ad..b71c86896cb 100644 --- a/solr/core/src/java/org/apache/solr/cli/PackageTool.java +++ b/solr/core/src/java/org/apache/solr/cli/PackageTool.java @@ -115,8 +115,8 @@ public String getName() { + "don't print stack traces, hence special treatment is needed here.") public void runImpl(CommandLine cli) throws Exception { try { - String solrUrl = SolrCLI.normalizeSolrUrl(cli); - String zkHost = SolrCLI.getZkHost(cli); + String solrUrl = CLIUtils.normalizeSolrUrl(cli); + String zkHost = CLIUtils.getZkHost(cli); if (zkHost == null) { throw new SolrException(ErrorCode.INVALID_STATE, "Package manager runs only in SolrCloud"); } @@ -125,7 +125,7 @@ public void runImpl(CommandLine cli) throws Exception { String cmd = cli.getArgs()[0]; - try (SolrClient solrClient = SolrCLI.getSolrClient(cli, true)) { + try (SolrClient solrClient = CLIUtils.getSolrClient(cli, true)) { packageManager = new PackageManager(solrClient, solrUrl, zkHost); try { repositoryManager = new RepositoryManager(solrClient, packageManager); diff --git a/solr/core/src/java/org/apache/solr/cli/PostLogsTool.java b/solr/core/src/java/org/apache/solr/cli/PostLogsTool.java index e1efeb0b920..c14d9c216db 100644 --- a/solr/core/src/java/org/apache/solr/cli/PostLogsTool.java +++ b/solr/core/src/java/org/apache/solr/cli/PostLogsTool.java @@ -93,7 +93,7 @@ public Options getOptions() { public void runImpl(CommandLine cli) throws Exception { String url = null; if (cli.hasOption(CommonCLIOptions.SOLR_URL_OPTION)) { - url = SolrCLI.normalizeSolrUrl(cli) + "/solr/" + cli.getOptionValue(COLLECTION_NAME_OPTION); + url = CLIUtils.normalizeSolrUrl(cli) + "/solr/" + cli.getOptionValue(COLLECTION_NAME_OPTION); } else { // Could be required arg, but maybe we want to support --zk-host option too? diff --git a/solr/core/src/java/org/apache/solr/cli/PostTool.java b/solr/core/src/java/org/apache/solr/cli/PostTool.java index 0e50e619043..f6bc4b811f0 100644 --- a/solr/core/src/java/org/apache/solr/cli/PostTool.java +++ b/solr/core/src/java/org/apache/solr/cli/PostTool.java @@ -279,7 +279,7 @@ public void runImpl(CommandLine cli) throws Exception { solrUpdateUrl = null; if (cli.hasOption(CommonCLIOptions.SOLR_URL_OPTION)) { String url = - SolrCLI.normalizeSolrUrl(cli) + CLIUtils.normalizeSolrUrl(cli) + "/solr/" + cli.getOptionValue(COLLECTION_NAME_OPTION) + "/update"; @@ -287,7 +287,7 @@ public void runImpl(CommandLine cli) throws Exception { } else { String url = - SolrCLI.getDefaultSolrUrl() + CLIUtils.getDefaultSolrUrl() + "/solr/" + cli.getOptionValue(COLLECTION_NAME_OPTION) + "/update"; @@ -765,7 +765,7 @@ public void commit() throws IOException, SolrServerException { info("COMMITting Solr index changes to " + solrUpdateUrl + "..."); String url = solrUpdateUrl.toString(); url = url.substring(0, url.lastIndexOf("/update")); - try (final SolrClient client = SolrCLI.getSolrClient(url, credentials)) { + try (final SolrClient client = CLIUtils.getSolrClient(url, credentials)) { client.commit(); } } @@ -775,7 +775,7 @@ public void optimize() throws IOException, SolrServerException { info("Performing an OPTIMIZE to " + solrUpdateUrl + "..."); String url = solrUpdateUrl.toString(); url = url.substring(0, url.lastIndexOf("/update")); - try (final SolrClient client = SolrCLI.getSolrClient(url, credentials)) { + try (final SolrClient client = CLIUtils.getSolrClient(url, credentials)) { client.optimize(); } } diff --git a/solr/core/src/java/org/apache/solr/cli/RunExampleTool.java b/solr/core/src/java/org/apache/solr/cli/RunExampleTool.java index 99307cf74f0..fff3c04f5c5 100644 --- a/solr/core/src/java/org/apache/solr/cli/RunExampleTool.java +++ b/solr/core/src/java/org/apache/solr/cli/RunExampleTool.java @@ -286,7 +286,7 @@ protected void runExample(CommandLine cli, String exampleName) throws Exception boolean alreadyExists = false; boolean cloudMode = nodeStatus.get("cloud") != null; if (cloudMode) { - if (SolrCLI.safeCheckCollectionExists( + if (CLIUtils.safeCheckCollectionExists( solrUrl, collectionName, cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION))) { alreadyExists = true; echo( @@ -296,7 +296,7 @@ protected void runExample(CommandLine cli, String exampleName) throws Exception } } else { String coreName = collectionName; - if (SolrCLI.safeCheckCoreExists( + if (CLIUtils.safeCheckCoreExists( solrUrl, coreName, cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION))) { alreadyExists = true; echo( @@ -800,7 +800,7 @@ protected String createCloudExampleCollection( // Test for existence and then prompt to either create another collection or skip the // creation step - if (SolrCLI.safeCheckCollectionExists(solrUrl, credentials, collectionName)) { + if (CLIUtils.safeCheckCollectionExists(solrUrl, credentials, collectionName)) { echo("\nCollection '" + collectionName + "' already exists!"); int oneOrTwo = promptForInt( @@ -856,7 +856,7 @@ protected String createCloudExampleCollection( } } else { // must verify if default collection exists - if (SolrCLI.safeCheckCollectionExists(solrUrl, collectionName, credentials)) { + if (CLIUtils.safeCheckCollectionExists(solrUrl, collectionName, credentials)) { echo( "\nCollection '" + collectionName diff --git a/solr/core/src/java/org/apache/solr/cli/SnapshotCreateTool.java b/solr/core/src/java/org/apache/solr/cli/SnapshotCreateTool.java index 236a7416832..49cce02a15c 100644 --- a/solr/core/src/java/org/apache/solr/cli/SnapshotCreateTool.java +++ b/solr/core/src/java/org/apache/solr/cli/SnapshotCreateTool.java @@ -71,7 +71,7 @@ public Options getOptions() { public void runImpl(CommandLine cli) throws Exception { String snapshotName = cli.getOptionValue(SNAPSHOT_NAME_OPTION); String collectionName = cli.getOptionValue(COLLECTION_NAME_OPTION); - try (var solrClient = SolrCLI.getSolrClient(cli)) { + try (var solrClient = CLIUtils.getSolrClient(cli)) { createSnapshot(solrClient, collectionName, snapshotName); } } diff --git a/solr/core/src/java/org/apache/solr/cli/SnapshotDeleteTool.java b/solr/core/src/java/org/apache/solr/cli/SnapshotDeleteTool.java index 53fa8ad002a..c9dc90abab7 100644 --- a/solr/core/src/java/org/apache/solr/cli/SnapshotDeleteTool.java +++ b/solr/core/src/java/org/apache/solr/cli/SnapshotDeleteTool.java @@ -71,7 +71,7 @@ public Options getOptions() { public void runImpl(CommandLine cli) throws Exception { String snapshotName = cli.getOptionValue(SNAPSHOT_NAME_OPTION); String collectionName = cli.getOptionValue(COLLECTION_NAME_OPTION); - try (var solrClient = SolrCLI.getSolrClient(cli)) { + try (var solrClient = CLIUtils.getSolrClient(cli)) { deleteSnapshot(solrClient, collectionName, snapshotName); } } diff --git a/solr/core/src/java/org/apache/solr/cli/SnapshotDescribeTool.java b/solr/core/src/java/org/apache/solr/cli/SnapshotDescribeTool.java index b76f36a7420..dcae8619f3e 100644 --- a/solr/core/src/java/org/apache/solr/cli/SnapshotDescribeTool.java +++ b/solr/core/src/java/org/apache/solr/cli/SnapshotDescribeTool.java @@ -84,7 +84,7 @@ public Options getOptions() { public void runImpl(CommandLine cli) throws Exception { String snapshotName = cli.getOptionValue(SNAPSHOT_NAME_OPTION); String collectionName = cli.getOptionValue(COLLECTION_NAME_OPTION); - try (var solrClient = SolrCLI.getSolrClient(cli)) { + try (var solrClient = CLIUtils.getSolrClient(cli)) { describeSnapshot(solrClient, collectionName, snapshotName); } } diff --git a/solr/core/src/java/org/apache/solr/cli/SnapshotExportTool.java b/solr/core/src/java/org/apache/solr/cli/SnapshotExportTool.java index a51e91badb3..6b8cf3a45d0 100644 --- a/solr/core/src/java/org/apache/solr/cli/SnapshotExportTool.java +++ b/solr/core/src/java/org/apache/solr/cli/SnapshotExportTool.java @@ -106,7 +106,7 @@ public void runImpl(CommandLine cli) throws Exception { Optional backupRepo = Optional.ofNullable(cli.getOptionValue(BACKUP_REPO_NAME_OPTION)); Optional asyncReqId = Optional.ofNullable(cli.getOptionValue(ASYNC_ID_OPTION)); - try (var solrClient = SolrCLI.getSolrClient(cli)) { + try (var solrClient = CLIUtils.getSolrClient(cli)) { exportSnapshot(solrClient, collectionName, snapshotName, destDir, backupRepo, asyncReqId); } } diff --git a/solr/core/src/java/org/apache/solr/cli/SnapshotListTool.java b/solr/core/src/java/org/apache/solr/cli/SnapshotListTool.java index 87219ce6021..4b952199e1b 100644 --- a/solr/core/src/java/org/apache/solr/cli/SnapshotListTool.java +++ b/solr/core/src/java/org/apache/solr/cli/SnapshotListTool.java @@ -62,7 +62,7 @@ public Options getOptions() { @Override public void runImpl(CommandLine cli) throws Exception { String collectionName = cli.getOptionValue(COLLECTION_NAME_OPTION); - try (var solrClient = SolrCLI.getSolrClient(cli)) { + try (var solrClient = CLIUtils.getSolrClient(cli)) { listSnapshots(solrClient, collectionName); } } diff --git a/solr/core/src/java/org/apache/solr/cli/SolrCLI.java b/solr/core/src/java/org/apache/solr/cli/SolrCLI.java index 4714c43c99c..32483720d17 100755 --- a/solr/core/src/java/org/apache/solr/cli/SolrCLI.java +++ b/solr/core/src/java/org/apache/solr/cli/SolrCLI.java @@ -16,32 +16,19 @@ */ package org.apache.solr.cli; -import static org.apache.solr.common.SolrException.ErrorCode.FORBIDDEN; -import static org.apache.solr.common.SolrException.ErrorCode.UNAUTHORIZED; -import static org.apache.solr.common.params.CommonParams.NAME; -import static org.apache.solr.common.params.CommonParams.SYSTEM_INFO_PATH; - import com.google.common.annotations.VisibleForTesting; import java.io.File; -import java.io.IOException; import java.lang.invoke.MethodHandles; -import java.net.SocketException; import java.net.URI; import java.net.URL; -import java.nio.file.Path; -import java.nio.file.Paths; import java.util.ArrayList; import java.util.Arrays; -import java.util.Collections; import java.util.Enumeration; import java.util.List; import java.util.Locale; -import java.util.Map; import java.util.Objects; -import java.util.Optional; import java.util.Set; import java.util.TreeSet; -import java.util.concurrent.TimeUnit; import java.util.zip.ZipEntry; import java.util.zip.ZipInputStream; import org.apache.commons.cli.CommandLine; @@ -51,22 +38,8 @@ import org.apache.commons.cli.Options; import org.apache.commons.cli.ParseException; import org.apache.solr.client.solrj.SolrClient; -import org.apache.solr.client.solrj.SolrRequest; -import org.apache.solr.client.solrj.SolrServerException; -import org.apache.solr.client.solrj.impl.CloudHttp2SolrClient; -import org.apache.solr.client.solrj.impl.CloudSolrClient; -import org.apache.solr.client.solrj.impl.Http2SolrClient; -import org.apache.solr.client.solrj.impl.SolrZkClientTimeout; -import org.apache.solr.client.solrj.request.CollectionAdminRequest; import org.apache.solr.client.solrj.request.ContentStreamUpdateRequest; -import org.apache.solr.client.solrj.request.CoreAdminRequest; -import org.apache.solr.client.solrj.request.GenericSolrRequest; -import org.apache.solr.common.SolrException; -import org.apache.solr.common.cloud.SolrZkClient; -import org.apache.solr.common.cloud.ZkStateReader; -import org.apache.solr.common.params.CommonParams; import org.apache.solr.common.util.ContentStreamBase; -import org.apache.solr.common.util.EnvUtils; import org.apache.solr.common.util.NamedList; import org.apache.solr.util.configuration.SSLConfigurationsFactory; import org.slf4j.Logger; @@ -75,13 +48,6 @@ /** Command-line utility for working with Solr. */ public class SolrCLI implements CLIO { - public static String RED = "\u001B[31m"; - public static String GREEN = "\u001B[32m"; - public static String YELLOW = "\u001B[33m"; - - private static final long MAX_WAIT_FOR_CORE_LOAD_NANOS = - TimeUnit.NANOSECONDS.convert(1, TimeUnit.MINUTES); - private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass()); public static void exit(int exitStatus) { @@ -188,14 +154,6 @@ public static CommandLine parseCmdLine(Tool tool, String[] args) { return cli; } - public static String getDefaultSolrUrl() { - // note that ENV_VAR syntax (and the env vars too) are mapped to env.var sys props - String scheme = EnvUtils.getProperty("solr.url.scheme", "http"); - String host = EnvUtils.getProperty("solr.tool.host", "localhost"); - String port = EnvUtils.getProperty("jetty.port", "8983"); // from SOLR_PORT env - return String.format(Locale.ROOT, "%s://%s:%s", scheme.toLowerCase(Locale.ROOT), host, port); - } - protected static void checkSslStoreSysProp(String solrInstallDir, String key) { String sysProp = "javax.net.ssl." + key; String keyStore = System.getProperty(sysProp); @@ -408,70 +366,6 @@ private static Set findClasses(String path, String packageName) throws E return classes; } - /** - * Determine if a request to Solr failed due to a communication error, which is generally - * retry-able. - */ - public static boolean checkCommunicationError(Exception exc) { - Throwable rootCause = SolrException.getRootCause(exc); - return (rootCause instanceof SolrServerException || rootCause instanceof SocketException); - } - - public static void checkCodeForAuthError(int code) { - if (code == UNAUTHORIZED.code || code == FORBIDDEN.code) { - throw new SolrException( - SolrException.ErrorCode.getErrorCode(code), - "Solr requires authentication for request. Please supply valid credentials. HTTP code=" - + code); - } - } - - public static boolean exceptionIsAuthRelated(Exception exc) { - return (exc instanceof SolrException - && Arrays.asList(UNAUTHORIZED.code, FORBIDDEN.code).contains(((SolrException) exc).code())); - } - - public static SolrClient getSolrClient(String solrUrl, String credentials, boolean barePath) { - // today we require all urls to end in /solr, however in the future we will need to support the - // /api url end point instead. Eventually we want to have this method always - // return a bare url, and then individual calls decide if they are /solr or /api - // The /solr/ check is because sometimes a full url is passed in, like - // http://localhost:8983/solr/films_shard1_replica_n1/. - if (!barePath && !solrUrl.endsWith("/solr") && !solrUrl.contains("/solr/")) { - solrUrl = solrUrl + "/solr"; - } - Http2SolrClient.Builder builder = - new Http2SolrClient.Builder(solrUrl) - .withMaxConnectionsPerHost(32) - .withKeyStoreReloadInterval(-1, TimeUnit.SECONDS) - .withOptionalBasicAuthCredentials(credentials); - - return builder.build(); - } - - /** - * Helper method for all the places where we assume a /solr on the url. - * - * @param solrUrl The solr url that you want the client for - * @param credentials The username:password for basic auth. - * @return The SolrClient - */ - public static SolrClient getSolrClient(String solrUrl, String credentials) { - return getSolrClient(solrUrl, credentials, false); - } - - public static SolrClient getSolrClient(CommandLine cli, boolean barePath) throws Exception { - String solrUrl = SolrCLI.normalizeSolrUrl(cli); - String credentials = cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION); - return getSolrClient(solrUrl, credentials, barePath); - } - - public static SolrClient getSolrClient(CommandLine cli) throws Exception { - String solrUrl = SolrCLI.normalizeSolrUrl(cli); - String credentials = cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION); - return getSolrClient(solrUrl, credentials, false); - } - private static final String JSON_CONTENT_TYPE = "application/json"; public static NamedList postJsonToSolr( @@ -540,204 +434,18 @@ private static void printHelp() { print("For more help on how to use Solr, head to https://solr.apache.org/"); } - /** - * Strips off the end of solrUrl any /solr when a legacy solrUrl like http://localhost:8983/solr - * is used, and warns those users. In the future we'll have urls ending with /api as well. - * - * @param solrUrl The user supplied url to Solr. - * @return the solrUrl in the format that Solr expects to see internally. - */ - public static String normalizeSolrUrl(String solrUrl) { - return normalizeSolrUrl(solrUrl, true); - } - - /** - * Strips off the end of solrUrl any /solr when a legacy solrUrl like http://localhost:8983/solr - * is used, and optionally logs a warning. In the future we'll have urls ending with /api as well. - * - * @param solrUrl The user supplied url to Solr. - * @param logUrlFormatWarning If a warning message should be logged about the url format - * @return the solrUrl in the format that Solr expects to see internally. - */ - public static String normalizeSolrUrl(String solrUrl, boolean logUrlFormatWarning) { - if (solrUrl != null) { - URI uri = URI.create(solrUrl); - String urlPath = uri.getRawPath(); - if (urlPath != null && urlPath.contains("/solr")) { - String newSolrUrl = - uri.resolve(urlPath.substring(0, urlPath.lastIndexOf("/solr") + 1)).toString(); - if (logUrlFormatWarning) { - CLIO.err( - "WARNING: URLs provided to this tool needn't include Solr's context-root (e.g. \"/solr\"). Such URLs are deprecated and support for them will be removed in a future release. Correcting from [" - + solrUrl - + "] to [" - + newSolrUrl - + "]."); - } - solrUrl = newSolrUrl; - } - if (solrUrl.endsWith("/")) { - solrUrl = solrUrl.substring(0, solrUrl.length() - 1); - } - } - return solrUrl; - } - - /** - * Get the base URL of a live Solr instance from either the --solr-url command-line option or from - * ZooKeeper. - */ - public static String normalizeSolrUrl(CommandLine cli) throws Exception { - String solrUrl = cli.getOptionValue(CommonCLIOptions.SOLR_URL_OPTION); - if (solrUrl == null) { - String zkHost = cli.getOptionValue(CommonCLIOptions.ZK_HOST_OPTION); - if (zkHost == null) { - solrUrl = SolrCLI.getDefaultSolrUrl(); - CLIO.err( - "Neither --zk-host or --solr-url parameters provided so assuming solr url is " - + solrUrl - + "."); - } else { - try (CloudSolrClient cloudSolrClient = getCloudHttp2SolrClient(zkHost)) { - cloudSolrClient.connect(); - Set liveNodes = cloudSolrClient.getClusterState().getLiveNodes(); - if (liveNodes.isEmpty()) - throw new IllegalStateException( - "No live nodes found! Cannot determine 'solrUrl' from ZooKeeper: " + zkHost); - - String firstLiveNode = liveNodes.iterator().next(); - solrUrl = ZkStateReader.from(cloudSolrClient).getBaseUrlForNodeName(firstLiveNode); - solrUrl = normalizeSolrUrl(solrUrl, false); - } - } - } - solrUrl = normalizeSolrUrl(solrUrl); - return solrUrl; - } - - /** - * Get the ZooKeeper connection string from either the zk-host command-line option or by looking - * it up from a running Solr instance based on the solr-url option. - */ - public static String getZkHost(CommandLine cli) throws Exception { - - String zkHost = cli.getOptionValue(CommonCLIOptions.ZK_HOST_OPTION); - if (zkHost != null && !zkHost.isBlank()) { - return zkHost; - } - - try (SolrClient solrClient = getSolrClient(cli)) { - // hit Solr to get system info - NamedList systemInfo = - solrClient.request( - new GenericSolrRequest(SolrRequest.METHOD.GET, CommonParams.SYSTEM_INFO_PATH)); - - // convert raw JSON into user-friendly output - StatusTool statusTool = new StatusTool(); - Map status = statusTool.reportStatus(systemInfo, solrClient); - @SuppressWarnings("unchecked") - Map cloud = (Map) status.get("cloud"); - if (cloud != null) { - String zookeeper = (String) cloud.get("ZooKeeper"); - if (zookeeper.endsWith("(embedded)")) { - zookeeper = zookeeper.substring(0, zookeeper.length() - "(embedded)".length()); - } - zkHost = zookeeper; - } - } - - return zkHost; - } - - public static SolrZkClient getSolrZkClient(CommandLine cli, String zkHost) throws Exception { - if (zkHost == null) { - throw new IllegalStateException( - "Solr at " - + cli.getOptionValue(CommonCLIOptions.SOLR_URL_OPTION) - + " is running in standalone server mode, this command can only be used when running in SolrCloud mode.\n"); - } - return new SolrZkClient.Builder() - .withUrl(zkHost) - .withTimeout(SolrZkClientTimeout.DEFAULT_ZK_CLIENT_TIMEOUT, TimeUnit.MILLISECONDS) - .build(); - } - - public static CloudHttp2SolrClient getCloudHttp2SolrClient(String zkHost) { - return getCloudHttp2SolrClient(zkHost, null); - } - - public static CloudHttp2SolrClient getCloudHttp2SolrClient( - String zkHost, Http2SolrClient.Builder builder) { - return new CloudHttp2SolrClient.Builder(Collections.singletonList(zkHost), Optional.empty()) - .withInternalClientBuilder(builder) - .build(); - } - - public static boolean safeCheckCollectionExists( - String solrUrl, String collection, String credentials) { - boolean exists = false; - try (var solrClient = getSolrClient(solrUrl, credentials)) { - NamedList existsCheckResult = solrClient.request(new CollectionAdminRequest.List()); - @SuppressWarnings("unchecked") - List collections = (List) existsCheckResult.get("collections"); - exists = collections != null && collections.contains(collection); - } catch (Exception exc) { - // just ignore it since we're only interested in a positive result here - } - return exists; - } - - @SuppressWarnings("unchecked") - public static boolean safeCheckCoreExists(String solrUrl, String coreName, String credentials) { - boolean exists = false; - try (var solrClient = getSolrClient(solrUrl, credentials)) { - boolean wait = false; - final long startWaitAt = System.nanoTime(); - do { - if (wait) { - final int clamPeriodForStatusPollMs = 1000; - Thread.sleep(clamPeriodForStatusPollMs); - } - NamedList existsCheckResult = - CoreAdminRequest.getStatus(coreName, solrClient).getResponse(); - NamedList status = (NamedList) existsCheckResult.get("status"); - NamedList coreStatus = (NamedList) status.get(coreName); - Map failureStatus = - (Map) existsCheckResult.get("initFailures"); - String errorMsg = (String) failureStatus.get(coreName); - final boolean hasName = coreStatus != null && coreStatus.asMap().containsKey(NAME); - exists = hasName || errorMsg != null; - wait = hasName && errorMsg == null && "true".equals(coreStatus.get("isLoading")); - } while (wait && System.nanoTime() - startWaitAt < MAX_WAIT_FOR_CORE_LOAD_NANOS); - } catch (Exception exc) { - // just ignore it since we're only interested in a positive result here - } - return exists; - } - - public static boolean isCloudMode(SolrClient solrClient) throws SolrServerException, IOException { - NamedList systemInfo = - solrClient.request(new GenericSolrRequest(SolrRequest.METHOD.GET, SYSTEM_INFO_PATH)); - return "solrcloud".equals(systemInfo.get("mode")); - } - - public static Path getConfigSetsDir(Path solrInstallDir) { - Path configSetsPath = Paths.get("server/solr/configsets/"); - return solrInstallDir.resolve(configSetsPath); - } - public static void print(Object message) { print(null, message); } /** Console print using green color */ public static void printGreen(Object message) { - print(GREEN, message); + print(CLIUtils.GREEN, message); } /** Console print using red color */ public static void printRed(Object message) { - print(RED, message); + print(CLIUtils.RED, message); } public static void print(String color, Object message) { diff --git a/solr/core/src/java/org/apache/solr/cli/StatusTool.java b/solr/core/src/java/org/apache/solr/cli/StatusTool.java index dcf0200e511..45713fbc085 100644 --- a/solr/core/src/java/org/apache/solr/cli/StatusTool.java +++ b/solr/core/src/java/org/apache/solr/cli/StatusTool.java @@ -18,8 +18,6 @@ package org.apache.solr.cli; import java.io.PrintStream; -import java.net.URI; -import java.net.URISyntaxException; import java.util.Collection; import java.util.LinkedHashMap; import java.util.List; @@ -188,25 +186,15 @@ private void printProcessStatus(SolrProcess process, CommandLine cli) throws Exc CLIO.out(""); } - private Integer portFromUrl(String solrUrl) { + public void waitForSolrUpAndPrintStatus(String solrUrl, CommandLine cli, int maxWaitSecs) + throws Exception { + int solrPort = -1; try { - URI uri = new URI(solrUrl); - int port = uri.getPort(); - if (port == -1) { - return uri.getScheme().equals("https") ? 443 : 80; - } else { - return port; - } - } catch (URISyntaxException e) { + solrPort = CLIUtils.portFromUrl(solrUrl); + } catch (Exception e) { CLIO.err("Invalid URL provided, does not contain port"); - System.exit(1); - return null; + SolrCLI.exit(1); } - } - - public void waitForSolrUpAndPrintStatus(String solrUrl, CommandLine cli, int maxWaitSecs) - throws Exception { - int solrPort = portFromUrl(solrUrl); echo("Waiting up to " + maxWaitSecs + " seconds to see Solr running on port " + solrPort); boolean solrUp = waitForSolrUp(solrUrl, cli, maxWaitSecs); if (solrUp) { @@ -268,10 +256,10 @@ public String statusFromRunningSolr(String solrUrl, CommandLine cli) throws Exce .write(getStatus(solrUrl, cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION))); return arr.toString(); } catch (Exception exc) { - if (SolrCLI.exceptionIsAuthRelated(exc)) { + if (CLIUtils.exceptionIsAuthRelated(exc)) { throw exc; } - if (SolrCLI.checkCommunicationError(exc)) { + if (CLIUtils.checkCommunicationError(exc)) { // this is not actually an error from the tool as it's ok if Solr is not online. return null; } else { @@ -289,7 +277,7 @@ public Map waitToSeeSolrUp( try { return getStatus(solrUrl, credentials); } catch (Exception exc) { - if (SolrCLI.exceptionIsAuthRelated(exc)) { + if (CLIUtils.exceptionIsAuthRelated(exc)) { throw exc; } try { @@ -308,7 +296,7 @@ public Map waitToSeeSolrUp( } public Map getStatus(String solrUrl, String credentials) throws Exception { - try (var solrClient = SolrCLI.getSolrClient(solrUrl, credentials)) { + try (var solrClient = CLIUtils.getSolrClient(solrUrl, credentials)) { return getStatus(solrClient); } } diff --git a/solr/core/src/java/org/apache/solr/cli/StreamTool.java b/solr/core/src/java/org/apache/solr/cli/StreamTool.java index 9c0392ec71b..512b678da0f 100644 --- a/solr/core/src/java/org/apache/solr/cli/StreamTool.java +++ b/solr/core/src/java/org/apache/solr/cli/StreamTool.java @@ -253,7 +253,7 @@ public void runImpl(CommandLine cli) throws Exception { * locally. */ private PushBackStream doLocalMode(CommandLine cli, String expr) throws Exception { - String zkHost = SolrCLI.getZkHost(cli); + String zkHost = CLIUtils.getZkHost(cli); echoIfVerbose("Connecting to ZooKeeper at " + zkHost); solrClientCache.getCloudSolrClient(zkHost); @@ -306,7 +306,7 @@ private PushBackStream doLocalMode(CommandLine cli, String expr) throws Exceptio */ private PushBackStream doRemoteMode(CommandLine cli, String expr) throws Exception { - String solrUrl = SolrCLI.normalizeSolrUrl(cli); + String solrUrl = CLIUtils.normalizeSolrUrl(cli); if (!cli.hasOption("name")) { throw new IllegalStateException( "You must provide --name COLLECTION with --worker solr parameter."); diff --git a/solr/core/src/java/org/apache/solr/cli/UpdateACLTool.java b/solr/core/src/java/org/apache/solr/cli/UpdateACLTool.java index 996ada0a213..bf54152d2ac 100644 --- a/solr/core/src/java/org/apache/solr/cli/UpdateACLTool.java +++ b/solr/core/src/java/org/apache/solr/cli/UpdateACLTool.java @@ -59,7 +59,7 @@ public Options getOptions() { @Override public void runImpl(CommandLine cli) throws Exception { - String zkHost = SolrCLI.getZkHost(cli); + String zkHost = CLIUtils.getZkHost(cli); String path = cli.getArgs()[0]; if (!ZkController.checkChrootPath(zkHost, true)) { diff --git a/solr/core/src/java/org/apache/solr/cli/ZkCpTool.java b/solr/core/src/java/org/apache/solr/cli/ZkCpTool.java index b2045ef3541..7f901e67cf2 100644 --- a/solr/core/src/java/org/apache/solr/cli/ZkCpTool.java +++ b/solr/core/src/java/org/apache/solr/cli/ZkCpTool.java @@ -124,7 +124,7 @@ public String getHeader() { @Override public void runImpl(CommandLine cli) throws Exception { - String zkHost = SolrCLI.getZkHost(cli); + String zkHost = CLIUtils.getZkHost(cli); echoIfVerbose("\nConnecting to ZooKeeper at " + zkHost + " ..."); String src = cli.getArgs()[0]; diff --git a/solr/core/src/java/org/apache/solr/cli/ZkLsTool.java b/solr/core/src/java/org/apache/solr/cli/ZkLsTool.java index c8f1f55b266..57bb45d4e40 100644 --- a/solr/core/src/java/org/apache/solr/cli/ZkLsTool.java +++ b/solr/core/src/java/org/apache/solr/cli/ZkLsTool.java @@ -57,10 +57,10 @@ public String getUsage() { @Override public void runImpl(CommandLine cli) throws Exception { - String zkHost = SolrCLI.getZkHost(cli); + String zkHost = CLIUtils.getZkHost(cli); String znode = cli.getArgs()[0]; - try (SolrZkClient zkClient = SolrCLI.getSolrZkClient(cli, zkHost)) { + try (SolrZkClient zkClient = CLIUtils.getSolrZkClient(cli, zkHost)) { echoIfVerbose("\nConnecting to ZooKeeper at " + zkHost + " ..."); boolean recursive = cli.hasOption(CommonCLIOptions.RECURSIVE_OPTION); diff --git a/solr/core/src/java/org/apache/solr/cli/ZkMkrootTool.java b/solr/core/src/java/org/apache/solr/cli/ZkMkrootTool.java index f2dc3703835..ace32ad5ce7 100644 --- a/solr/core/src/java/org/apache/solr/cli/ZkMkrootTool.java +++ b/solr/core/src/java/org/apache/solr/cli/ZkMkrootTool.java @@ -76,11 +76,11 @@ public String getHeader() { @Override public void runImpl(CommandLine cli) throws Exception { - String zkHost = SolrCLI.getZkHost(cli); + String zkHost = CLIUtils.getZkHost(cli); String znode = cli.getArgs()[0]; boolean failOnExists = cli.hasOption(FAIL_ON_EXISTS_OPTION); - try (SolrZkClient zkClient = SolrCLI.getSolrZkClient(cli, zkHost)) { + try (SolrZkClient zkClient = CLIUtils.getSolrZkClient(cli, zkHost)) { echoIfVerbose("\nConnecting to ZooKeeper at " + zkHost + " ..."); echo("Creating ZooKeeper path " + znode + " on ZooKeeper at " + zkHost); diff --git a/solr/core/src/java/org/apache/solr/cli/ZkMvTool.java b/solr/core/src/java/org/apache/solr/cli/ZkMvTool.java index 41ca7d78822..dba47d5b824 100644 --- a/solr/core/src/java/org/apache/solr/cli/ZkMvTool.java +++ b/solr/core/src/java/org/apache/solr/cli/ZkMvTool.java @@ -74,9 +74,9 @@ public String getHeader() { @Override public void runImpl(CommandLine cli) throws Exception { - String zkHost = SolrCLI.getZkHost(cli); + String zkHost = CLIUtils.getZkHost(cli); - try (SolrZkClient zkClient = SolrCLI.getSolrZkClient(cli, zkHost)) { + try (SolrZkClient zkClient = CLIUtils.getSolrZkClient(cli, zkHost)) { echoIfVerbose("\nConnecting to ZooKeeper at " + zkHost + " ..."); String src = cli.getArgs()[0]; String dst = cli.getArgs()[1]; diff --git a/solr/core/src/java/org/apache/solr/cli/ZkRmTool.java b/solr/core/src/java/org/apache/solr/cli/ZkRmTool.java index cdb2e600334..777ad6035a5 100644 --- a/solr/core/src/java/org/apache/solr/cli/ZkRmTool.java +++ b/solr/core/src/java/org/apache/solr/cli/ZkRmTool.java @@ -58,7 +58,7 @@ public String getUsage() { @Override public void runImpl(CommandLine cli) throws Exception { - String zkHost = SolrCLI.getZkHost(cli); + String zkHost = CLIUtils.getZkHost(cli); String target = cli.getArgs()[0]; boolean recursive = cli.hasOption(CommonCLIOptions.RECURSIVE_OPTION); @@ -71,7 +71,7 @@ public void runImpl(CommandLine cli) throws Exception { throw new SolrServerException("You may not remove the root ZK node ('/')!"); } echoIfVerbose("\nConnecting to ZooKeeper at " + zkHost + " ..."); - try (SolrZkClient zkClient = SolrCLI.getSolrZkClient(cli, zkHost)) { + try (SolrZkClient zkClient = CLIUtils.getSolrZkClient(cli, zkHost)) { if (!recursive && zkClient.getChildren(znode, null, true).size() != 0) { throw new SolrServerException( "ZooKeeper node " + znode + " has children and recursive has NOT been specified."); diff --git a/solr/core/src/java/org/apache/solr/packagemanager/PackageManager.java b/solr/core/src/java/org/apache/solr/packagemanager/PackageManager.java index a751d20472f..1d69a9c429d 100644 --- a/solr/core/src/java/org/apache/solr/packagemanager/PackageManager.java +++ b/solr/core/src/java/org/apache/solr/packagemanager/PackageManager.java @@ -40,6 +40,7 @@ import java.util.Set; import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; +import org.apache.solr.cli.CLIUtils; import org.apache.solr.cli.SolrCLI; import org.apache.solr.client.api.util.SolrVersion; import org.apache.solr.client.solrj.SolrClient; @@ -680,7 +681,7 @@ private boolean prompt(boolean noprompt) { boolean shouldExecute = true; if (!noprompt) { // show a prompt asking user to execute the setup command for the plugin PackageUtils.print( - SolrCLI.YELLOW, + CLIUtils.YELLOW, "Execute this command. (If you choose no, you can manually deploy/undeploy this plugin later) (y/n): "); try (Scanner scanner = new Scanner(System.in, StandardCharsets.UTF_8)) { String userInput = scanner.next(); @@ -954,7 +955,7 @@ public void deploy( shouldInstallClusterPlugins, parameters); PackageUtils.print( - res ? SolrCLI.GREEN : SolrCLI.RED, res ? "Deployment successful" : "Deployment failed"); + res ? CLIUtils.GREEN : CLIUtils.RED, res ? "Deployment successful" : "Deployment failed"); } /** Undeploys a package from given collections. */ diff --git a/solr/core/src/java/org/apache/solr/packagemanager/PackageUtils.java b/solr/core/src/java/org/apache/solr/packagemanager/PackageUtils.java index 26b294b4906..1d1270a2b84 100644 --- a/solr/core/src/java/org/apache/solr/packagemanager/PackageUtils.java +++ b/solr/core/src/java/org/apache/solr/packagemanager/PackageUtils.java @@ -33,7 +33,7 @@ import java.util.zip.ZipEntry; import java.util.zip.ZipFile; import org.apache.lucene.util.SuppressForbidden; -import org.apache.solr.cli.SolrCLI; +import org.apache.solr.cli.CLIUtils; import org.apache.solr.client.solrj.SolrClient; import org.apache.solr.client.solrj.SolrRequest; import org.apache.solr.client.solrj.SolrServerException; @@ -236,7 +236,7 @@ public static String resolve( /** Console print using green color */ public static void formatGreen(StringBuilder sb, Object message) { - format(sb, SolrCLI.GREEN, message); + format(sb, CLIUtils.GREEN, message); } public static void format(StringBuilder sb, Object message) { diff --git a/solr/core/src/test/org/apache/solr/cli/CLIUtilsTest.java b/solr/core/src/test/org/apache/solr/cli/CLIUtilsTest.java new file mode 100644 index 00000000000..928266de7c0 --- /dev/null +++ b/solr/core/src/test/org/apache/solr/cli/CLIUtilsTest.java @@ -0,0 +1,144 @@ +/* + * 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.cli; + +import java.net.SocketException; +import java.net.URISyntaxException; +import org.apache.solr.client.solrj.SolrServerException; +import org.apache.solr.cloud.SolrCloudTestCase; +import org.apache.solr.common.SolrException; +import org.junit.Test; + +public class CLIUtilsTest extends SolrCloudTestCase { + + @Test + public void testDefaultSolrUrlWithNoProperties() { + System.clearProperty("solr.url.scheme"); + System.clearProperty("solr.tool.host"); + System.clearProperty("jetty.port"); + assertEquals( + "Default Solr URL should match with no properties set.", + "http://localhost:8983", + CLIUtils.getDefaultSolrUrl()); + } + + @Test + public void testDefaultSolrUrlWithProperties() { + System.setProperty("solr.url.scheme", "https"); + System.setProperty("solr.tool.host", "other.local"); + System.setProperty("jetty.port", "1234"); + assertEquals( + "Default Solr URL should match with custom properties set.", + "https://other.local:1234", + CLIUtils.getDefaultSolrUrl()); + } + + @Test + public void testCommunicationErrors() { + // communication errors + Exception serverException = new Exception(new SolrServerException("")); + assertTrue( + "SolrServerException should be communication error", + CLIUtils.checkCommunicationError(serverException)); + + Exception socketException = new RuntimeException(new Exception(new SocketException())); + assertTrue( + "SocketException should be communication error", + CLIUtils.checkCommunicationError(socketException)); + + // TODO See if this should be a communication error or not + // Exception parentException = new SolrServerException(new Exception()); + // assertTrue( + // "SolrServerException with different root cause should be communication error", + // CLIUtils.checkCommunicationError(parentException)); + + Exception rootException = new SolrServerException(""); + assertTrue( + "SolrServerException with no cause should be communication error", + CLIUtils.checkCommunicationError(rootException)); + + // non-communication errors + Exception exception1 = new NullPointerException(); + assertFalse( + "NullPointerException should not be communication error", + CLIUtils.checkCommunicationError(exception1)); + + Exception exception2 = new RuntimeException(new Exception()); + assertFalse( + "Exception should not be communication error", + CLIUtils.checkCommunicationError(exception2)); + } + + @Test + public void testCodeForAuthError() throws SolrException { + // auth errors + assertThrows( + "Forbidden (403) should throw SolrException", + SolrException.class, + () -> CLIUtils.checkCodeForAuthError(SolrException.ErrorCode.FORBIDDEN.code)); + assertThrows( + "Unauthorized (401) should throw SolrException", + SolrException.class, + () -> CLIUtils.checkCodeForAuthError(SolrException.ErrorCode.UNAUTHORIZED.code)); + + // non auth errors + CLIUtils.checkCodeForAuthError(SolrException.ErrorCode.BAD_REQUEST.code); + CLIUtils.checkCodeForAuthError(SolrException.ErrorCode.CONFLICT.code); + CLIUtils.checkCodeForAuthError(SolrException.ErrorCode.SERVER_ERROR.code); + CLIUtils.checkCodeForAuthError(0); // Unknown + CLIUtils.checkCodeForAuthError(200); // HTTP OK + } + + @Test + public void testResolveSolrUrl() { + assertEquals(CLIUtils.normalizeSolrUrl("http://localhost:8983/solr"), "http://localhost:8983"); + assertEquals(CLIUtils.normalizeSolrUrl("http://localhost:8983/solr/"), "http://localhost:8983"); + assertEquals(CLIUtils.normalizeSolrUrl("http://localhost:8983/"), "http://localhost:8983"); + assertEquals(CLIUtils.normalizeSolrUrl("http://localhost:8983"), "http://localhost:8983"); + assertEquals( + CLIUtils.normalizeSolrUrl("http://localhost:8983/solr/", false), "http://localhost:8983"); + } + + @Test + public void testPortExtraction() throws URISyntaxException { + assertEquals( + "Should extract explicit port from valid URL", + 8983, + CLIUtils.portFromUrl("http://localhost:8983")); + + assertEquals( + "Should extract explicit port from valid URL with trailing slash", + 1234, + CLIUtils.portFromUrl("http://localhost:1234/")); + + assertEquals( + "Should extract implicit HTTP port (80)", 80, CLIUtils.portFromUrl("http://localhost")); + + assertEquals( + "Should extract implicit HTTPS port (443)", 443, CLIUtils.portFromUrl("https://localhost")); + + // TODO See if we could be more lenient and fallback to defaults instead. + assertThrows( + "Should throw NullpointerException if no scheme provided", + NullPointerException.class, + () -> CLIUtils.portFromUrl("localhost")); + + // Note that a bunch of invalid URIs like "http::example.com", "http:/example.com" and + // "//example.com" are not throwing URISyntaxException. This however is an issue of + // java.lang.URI, which is very lenient. + } +} diff --git a/solr/core/src/test/org/apache/solr/cli/SolrCLITest.java b/solr/core/src/test/org/apache/solr/cli/SolrCLITest.java index 4b5290a1ff7..d045ae35501 100644 --- a/solr/core/src/test/org/apache/solr/cli/SolrCLITest.java +++ b/solr/core/src/test/org/apache/solr/cli/SolrCLITest.java @@ -20,15 +20,6 @@ import org.junit.Test; public class SolrCLITest extends SolrTestCase { - @Test - public void testResolveSolrUrl() { - assertEquals(SolrCLI.normalizeSolrUrl("http://localhost:8983/solr"), "http://localhost:8983"); - assertEquals(SolrCLI.normalizeSolrUrl("http://localhost:8983/solr/"), "http://localhost:8983"); - assertEquals(SolrCLI.normalizeSolrUrl("http://localhost:8983/"), "http://localhost:8983"); - assertEquals(SolrCLI.normalizeSolrUrl("http://localhost:8983"), "http://localhost:8983"); - assertEquals( - SolrCLI.normalizeSolrUrl("http://localhost:8983/solr/", false), "http://localhost:8983"); - } @Test public void testUptime() { diff --git a/solr/core/src/test/org/apache/solr/cli/TestSolrCLIRunExample.java b/solr/core/src/test/org/apache/solr/cli/TestSolrCLIRunExample.java index 6c0522fd937..da279a12301 100644 --- a/solr/core/src/test/org/apache/solr/cli/TestSolrCLIRunExample.java +++ b/solr/core/src/test/org/apache/solr/cli/TestSolrCLIRunExample.java @@ -506,7 +506,7 @@ public void testInteractiveSolrCloudExample() throws Exception { // verify Solr is running on the expected port and verify the collection exists String solrUrl = "http://localhost:" + bindPort + "/solr"; - if (!SolrCLI.safeCheckCollectionExists(solrUrl, collectionName, null)) { + if (!CLIUtils.safeCheckCollectionExists(solrUrl, collectionName, null)) { fail( "After running Solr cloud example, test collection '" + collectionName diff --git a/solr/core/src/test/org/apache/solr/cloud/SolrCloudExampleTest.java b/solr/core/src/test/org/apache/solr/cloud/SolrCloudExampleTest.java index 1716d09a45f..8e2e728944f 100644 --- a/solr/core/src/test/org/apache/solr/cloud/SolrCloudExampleTest.java +++ b/solr/core/src/test/org/apache/solr/cloud/SolrCloudExampleTest.java @@ -24,6 +24,7 @@ import java.util.concurrent.TimeUnit; import org.apache.commons.cli.CommandLine; import org.apache.solr.SolrTestCaseJ4; +import org.apache.solr.cli.CLIUtils; import org.apache.solr.cli.CreateTool; import org.apache.solr.cli.DeleteTool; import org.apache.solr.cli.HealthcheckTool; @@ -174,7 +175,7 @@ protected void doTestDeleteAction(String testCollectionName, String solrUrl) thr CommandLine cli = SolrCLI.processCommandLineArgs(tool, args); assertEquals("Delete action failed!", 0, tool.runTool(cli)); assertFalse( - SolrCLI.safeCheckCollectionExists( + CLIUtils.safeCheckCollectionExists( solrUrl, testCollectionName, null)); // it should not exist anymore } } From 99ba2b96af4e10ded429c73fee3c6f1c09110496 Mon Sep 17 00:00:00 2001 From: Bruno Roustant Date: Wed, 20 Nov 2024 09:37:49 +0100 Subject: [PATCH 10/33] SOLR-17390: Move CHANGES.txt entry to the Other section. --- solr/CHANGES.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/solr/CHANGES.txt b/solr/CHANGES.txt index 80e4820ff25..03f52515880 100644 --- a/solr/CHANGES.txt +++ b/solr/CHANGES.txt @@ -167,8 +167,6 @@ Improvements * SOLR-17390: EmbeddedSolrServer now considers the ResponseParser (David Smiley) -* SOLR-17504: CoreContainer calls UpdateHandler.commit when closing a read-only core (Bruno Roustant) - Optimizations --------------------- * SOLR-14985: Solrj CloudSolrClient with Solr URLs had serious performance regressions (since the @@ -241,6 +239,8 @@ led to the suppression of exceptions. (Andrey Bozhko) * SOLR-17545: Upgrade to Gradle 8.10 (Houston Putman) +* SOLR-17504: CoreContainer calls UpdateHandler.commit when closing a read-only core (Bruno Roustant) + ================== 9.7.1 ================== Bug Fixes --------------------- From 66a16805be3142705bcfdf22806d4c2b4720b1a1 Mon Sep 17 00:00:00 2001 From: Christos Malliaridis Date: Wed, 20 Nov 2024 13:26:01 +0200 Subject: [PATCH 11/33] SOLR-17567: Fix auth issue in stream tests (#2877) * Fix auth issue in stream tests * Add negative test for missing auth --- .../src/java/org/apache/solr/cli/StreamTool.java | 2 +- solr/packaging/test/test_stream.bats | 16 +++++++++++++++- 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/solr/core/src/java/org/apache/solr/cli/StreamTool.java b/solr/core/src/java/org/apache/solr/cli/StreamTool.java index 512b678da0f..fba6c91809d 100644 --- a/solr/core/src/java/org/apache/solr/cli/StreamTool.java +++ b/solr/core/src/java/org/apache/solr/cli/StreamTool.java @@ -256,9 +256,9 @@ private PushBackStream doLocalMode(CommandLine cli, String expr) throws Exceptio String zkHost = CLIUtils.getZkHost(cli); echoIfVerbose("Connecting to ZooKeeper at " + zkHost); - solrClientCache.getCloudSolrClient(zkHost); solrClientCache.setBasicAuthCredentials( cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION)); + solrClientCache.getCloudSolrClient(zkHost); TupleStream stream; PushBackStream pushBackStream; diff --git a/solr/packaging/test/test_stream.bats b/solr/packaging/test/test_stream.bats index 63145522c79..b2f5072a3d8 100644 --- a/solr/packaging/test/test_stream.bats +++ b/solr/packaging/test/test_stream.bats @@ -20,7 +20,7 @@ load bats_helper setup_file() { common_clean_setup solr start -e techproducts - solr auth enable --type basicAuth --credentials name:password + solr auth enable --type basicAuth --credentials name:password --solr-include-file /force/credentials/to/be/supplied } teardown_file() { @@ -84,3 +84,17 @@ teardown() { assert_output --partial 'Apple 60 GB iPod' refute_output --partial 'ERROR' } + +@test "searching solr without credentials fails with error" { + + local solr_stream_file="${BATS_TEST_TMPDIR}/search.expr" + echo 'search(techproducts,' > "${solr_stream_file}" + echo 'q="name:memory",' >> "${solr_stream_file}" + echo 'fl="name,price",' >> "${solr_stream_file}" + echo 'sort="price desc"' >> "${solr_stream_file}" + echo ')' >> "${solr_stream_file}" + + run ! solr stream --execution local --header ${solr_stream_file} + + assert_output --partial 'ERROR' +} From b76a29d17c874806e3b6516810772e2238e93098 Mon Sep 17 00:00:00 2001 From: Christos Malliaridis Date: Wed, 20 Nov 2024 22:41:14 +0200 Subject: [PATCH 12/33] SOLR-16427: Enable error-prone PatternMatchingInstanceof rule (#2867) * Enable PatternMatchingInstanceof checks * Resolve PatternMatchingInstanceof warnings --- .../lucene/missingdoclet/MissingDoclet.java | 3 +- gradle/validation/error-prone.gradle | 2 +- .../bench/generators/RandomDataHistogram.java | 3 +- .../org/apache/solr/api/AnnotatedApi.java | 12 +++---- .../src/java/org/apache/solr/api/ApiBag.java | 13 +++----- .../solr/api/ContainerPluginsRegistry.java | 6 ++-- .../java/org/apache/solr/cli/ExportTool.java | 6 ++-- .../org/apache/solr/cli/HealthcheckTool.java | 3 +- .../java/org/apache/solr/cli/StreamTool.java | 3 +- .../solrj/embedded/EmbeddedSolrServer.java | 3 +- .../java/org/apache/solr/cloud/Overseer.java | 3 +- .../apache/solr/cloud/OverseerTaskQueue.java | 3 +- .../solr/cloud/RecoveringCoreTermWatcher.java | 3 +- .../org/apache/solr/cloud/ZkController.java | 6 ++-- .../cloud/api/collections/MigrateCmd.java | 6 ++-- .../cloud/api/collections/RoutedAlias.java | 3 +- .../cloud/api/collections/SplitShardCmd.java | 3 +- .../solr/cloud/overseer/SliceMutator.java | 3 +- .../impl/ClusterEventProducerFactory.java | 6 ++-- .../cluster/placement/impl/MetricImpl.java | 3 +- .../placement/impl/NodeMetricImpl.java | 3 +- .../impl/SimpleClusterAbstractionsImpl.java | 9 ++--- .../plugins/OrderedNodePlacementPlugin.java | 3 +- .../apache/solr/core/ClusterSingletons.java | 6 ++-- .../org/apache/solr/core/ConfigOverlay.java | 6 ++-- .../org/apache/solr/core/CoreContainer.java | 9 ++--- .../java/org/apache/solr/core/CoreSorter.java | 3 +- .../java/org/apache/solr/core/PluginBag.java | 6 ++-- .../java/org/apache/solr/core/PluginInfo.java | 6 ++-- .../apache/solr/core/QuerySenderListener.java | 6 ++-- .../org/apache/solr/core/RequestParams.java | 9 ++--- .../apache/solr/core/SchemaCodecFactory.java | 3 +- .../java/org/apache/solr/core/SolrConfig.java | 7 ++-- .../java/org/apache/solr/core/SolrCore.java | 12 +++---- .../apache/solr/core/SolrDeletionPolicy.java | 6 ++-- .../org/apache/solr/core/SolrXmlConfig.java | 3 +- .../org/apache/solr/core/backup/BackupId.java | 3 +- .../org/apache/solr/core/backup/Checksum.java | 5 ++- .../repository/BackupRepositoryFactory.java | 3 +- .../apache/solr/filestore/FileStoreAPI.java | 3 +- .../handler/AnalysisRequestHandlerBase.java | 3 +- .../solr/handler/MoreLikeThisHandler.java | 6 ++-- .../solr/handler/ReplicationHandler.java | 3 +- .../solr/handler/RequestHandlerBase.java | 3 +- .../solr/handler/SolrConfigHandler.java | 3 +- .../apache/solr/handler/StreamHandler.java | 3 +- .../handler/admin/IndexSizeEstimator.java | 12 +++---- .../handler/admin/LukeRequestHandler.java | 4 +-- .../admin/SegmentsInfoRequestHandler.java | 3 +- .../apache/solr/handler/admin/SplitOp.java | 6 ++-- .../solr/handler/admin/SystemInfoHandler.java | 3 +- .../solr/handler/admin/api/GetSchema.java | 3 +- .../handler/admin/api/GetSchemaField.java | 9 ++--- .../handler/component/DebugComponent.java | 3 +- .../handler/component/ExpandComponent.java | 4 +-- .../handler/component/QueryComponent.java | 3 +- .../component/QueryElevationComponent.java | 3 +- .../component/RealTimeGetComponent.java | 3 +- .../solr/handler/component/ShardDoc.java | 3 +- .../solr/handler/component/StatsField.java | 3 +- .../designer/DefaultSchemaSuggester.java | 3 +- .../SchemaDesignerConfigSetHelper.java | 3 +- .../designer/SchemaDesignerSettings.java | 3 +- .../solr/handler/loader/JavabinLoader.java | 3 +- .../solr/handler/loader/JsonLoader.java | 9 ++--- .../handler/tagger/TaggerRequestHandler.java | 3 +- .../solr/jersey/CatchAllExceptionMapper.java | 3 +- .../org/apache/solr/legacy/BBoxStrategy.java | 8 ++--- .../apache/solr/legacy/BBoxValueSource.java | 4 +-- .../apache/solr/legacy/LegacyFieldType.java | 3 +- .../solr/legacy/LegacyNumericRangeQuery.java | 3 +- .../solr/legacy/LegacyNumericTokenStream.java | 3 +- .../apache/solr/metrics/AggregateMetric.java | 15 +++------ .../apache/solr/metrics/SolrMetricInfo.java | 3 +- .../solr/metrics/SolrMetricManager.java | 3 +- .../prometheus/SolrPrometheusFormatter.java | 3 +- .../reporters/jmx/JmxMetricsReporter.java | 3 +- .../solr/parser/SolrQueryParserBase.java | 12 +++---- .../java/org/apache/solr/pkg/PackageAPI.java | 3 +- .../apache/solr/pkg/PackagePluginHolder.java | 6 ++-- .../org/apache/solr/query/FilterQuery.java | 6 ++-- .../org/apache/solr/query/SolrRangeQuery.java | 3 +- .../org/apache/solr/request/SimpleFacets.java | 6 ++-- .../solr/request/json/JsonQueryConverter.java | 3 +- .../apache/solr/request/json/RequestUtil.java | 3 +- .../solr/response/BinaryResponseWriter.java | 9 ++--- .../solr/response/CSVResponseWriter.java | 3 +- .../solr/response/GraphMLResponseWriter.java | 3 +- .../response/QueryResponseWriterUtil.java | 6 ++-- .../solr/response/RawResponseWriter.java | 9 ++--- .../solr/response/TextResponseWriter.java | 6 ++-- .../transform/BaseEditorialTransformer.java | 3 +- .../transform/GeoTransformerFactory.java | 3 +- .../transform/SubQueryAugmenterFactory.java | 3 +- .../analysis/ManagedSynonymFilterFactory.java | 3 +- .../ManagedSynonymGraphFilterFactory.java | 3 +- .../org/apache/solr/schema/BinaryField.java | 6 ++-- .../apache/solr/schema/CurrencyFieldType.java | 8 ++--- .../apache/solr/schema/DateRangeField.java | 3 +- .../schema/ExternalFileFieldReloader.java | 3 +- .../org/apache/solr/schema/FieldType.java | 3 +- .../solr/schema/FileExchangeRateProvider.java | 4 +-- .../org/apache/solr/schema/IndexSchema.java | 3 +- .../solr/schema/IndexSchemaFactory.java | 3 +- .../solr/schema/LatLonPointSpatialField.java | 24 +++++--------- .../schema/ManagedIndexSchemaFactory.java | 9 ++--- .../schema/OpenExchangeRatesOrgProvider.java | 3 +- .../apache/solr/schema/RandomSortField.java | 3 +- .../schema/RptWithGeometrySpatialField.java | 7 ++-- .../org/apache/solr/schema/SchemaManager.java | 6 ++-- .../apache/solr/schema/SortableTextField.java | 3 +- .../java/org/apache/solr/schema/StrField.java | 3 +- .../org/apache/solr/schema/TrieField.java | 3 +- .../solr/schema/ZkIndexSchemaReader.java | 3 +- .../org/apache/solr/search/BitDocSet.java | 3 +- .../solr/search/CollapsingQParserPlugin.java | 3 +- .../org/apache/solr/search/DisMaxQParser.java | 3 +- .../solr/search/ExtendedDismaxQParser.java | 15 +++------ .../solr/search/FloatPayloadValueSource.java | 3 +- .../apache/solr/search/FunctionQParser.java | 3 +- .../apache/solr/search/HashQParserPlugin.java | 6 ++-- .../solr/search/IGainTermsQParserPlugin.java | 3 +- .../apache/solr/search/MaxScoreQParser.java | 3 +- .../solr/search/MultiThreadedSearcher.java | 3 +- .../apache/solr/search/MutableBitDocSet.java | 3 +- .../org/apache/solr/search/QueryParsing.java | 21 ++++-------- .../apache/solr/search/QueryResultKey.java | 3 +- .../org/apache/solr/search/QueryUtils.java | 15 +++------ .../org/apache/solr/search/ReRankScaler.java | 3 +- .../search/SignificantTermsQParserPlugin.java | 3 +- .../apache/solr/search/SolrIndexSearcher.java | 9 ++--- .../apache/solr/search/SolrReturnFields.java | 3 +- .../apache/solr/search/SortSpecParsing.java | 3 +- .../solr/search/SpatialFilterQParser.java | 3 +- .../apache/solr/search/TopLevelJoinQuery.java | 3 +- .../apache/solr/search/ValueSourceParser.java | 12 +++---- .../search/facet/FacetFieldProcessor.java | 4 +-- .../facet/FacetFieldProcessorByArrayDV.java | 8 ++--- .../facet/FacetFieldProcessorByHashDV.java | 4 +-- .../solr/search/facet/FacetHeatmap.java | 7 ++-- .../apache/solr/search/facet/FacetParser.java | 3 +- .../search/facet/FacetRangeProcessor.java | 3 +- .../solr/search/facet/FacetRequest.java | 3 +- .../apache/solr/search/facet/FieldUtil.java | 8 ++--- .../solr/search/facet/PercentileAgg.java | 3 +- .../solr/search/facet/RelatednessAgg.java | 6 ++-- .../search/function/DualDoubleFunction.java | 3 +- .../solr/search/function/FileFloatSource.java | 6 ++-- .../search/function/MultiStringFunction.java | 3 +- .../solr/search/function/OrdFieldSource.java | 4 +-- .../function/ReverseOrdFieldSource.java | 7 ++-- .../function/ValueSourceRangeFilter.java | 3 +- .../distance/GeoDistValueSourceParser.java | 3 +- .../function/distance/GeohashFunction.java | 4 +-- .../distance/GeohashHaversineFunction.java | 3 +- .../distance/HaversineConstFunction.java | 3 +- .../function/distance/HaversineFunction.java | 3 +- .../distance/SquaredEuclideanFunction.java | 4 +-- .../distance/StringDistanceFunction.java | 4 +-- .../distance/VectorDistanceFunction.java | 4 +-- .../SearchGroupsResultTransformer.java | 3 +- .../TopGroupsResultTransformer.java | 12 +++---- .../MainEndResultTransformer.java | 3 +- .../SimpleEndResultTransformer.java | 3 +- .../join/ChildFieldValueSourceParser.java | 3 +- .../solr/search/join/FiltersQParser.java | 3 +- .../search/join/ScoreJoinQParserPlugin.java | 3 +- .../solr/search/mlt/AbstractMLTQParser.java | 3 +- .../apache/solr/security/BasicAuthPlugin.java | 16 +++------ .../org/apache/solr/security/Permission.java | 3 +- .../RuleBasedAuthorizationPluginBase.java | 3 +- .../apache/solr/servlet/ResponseUtils.java | 12 +++---- .../solr/spelling/PossibilityIterator.java | 3 +- .../org/apache/solr/spelling/ResultEntry.java | 3 +- .../java/org/apache/solr/spelling/Token.java | 3 +- .../solr/uninverting/FieldCacheImpl.java | 3 +- .../java/org/apache/solr/update/PeerSync.java | 7 ++-- .../solr/update/SolrCmdDistributor.java | 6 ++-- .../apache/solr/update/SolrIndexSplitter.java | 3 +- .../apache/solr/update/TransactionLog.java | 6 ++-- .../org/apache/solr/update/UpdateLog.java | 3 +- ...AddSchemaFieldsUpdateProcessorFactory.java | 6 ++-- .../processor/AtomicUpdateDocumentMerger.java | 6 ++-- .../CloneFieldUpdateProcessorFactory.java | 6 ++-- .../processor/DistributedUpdateProcessor.java | 3 +- .../DistributedZkUpdateProcessor.java | 12 +++---- .../FieldMutatingUpdateProcessorFactory.java | 3 +- .../HTMLStripFieldUpdateProcessorFactory.java | 3 +- .../LastFieldValueUpdateProcessorFactory.java | 3 +- .../NestedUpdateProcessorFactory.java | 3 +- .../RegexReplaceProcessorFactory.java | 3 +- .../processor/TolerantUpdateProcessor.java | 3 +- .../TruncateFieldUpdateProcessorFactory.java | 3 +- .../UpdateRequestProcessorChain.java | 3 +- .../org/apache/solr/util/PayloadUtils.java | 3 +- .../util/SolrJacksonAnnotationInspector.java | 6 ++-- .../org/apache/solr/util/SolrPluginUtils.java | 3 +- .../circuitbreaker/CPUCircuitBreaker.java | 4 +-- .../InstrumentedHttpRequestExecutor.java | 6 ++-- .../apache/solr/util/stats/MetricUtils.java | 18 ++++------ .../solr/util/vector/DenseVectorParser.java | 3 +- .../apache/solr/TestDistributedSearch.java | 3 +- .../src/test/org/apache/solr/TestTrie.java | 3 +- ...stribDocExpirationUpdateProcessorTest.java | 3 +- .../cloud/TestOnReconnectListenerSupport.java | 9 ++--- .../cloud/api/collections/ShardSplitTest.java | 3 +- .../solr/core/TestSolrConfigHandler.java | 7 ++-- .../solr/handler/admin/TestApiFramework.java | 3 +- .../DistributedFacetPivotSmallTest.java | 6 ++-- .../solr/handler/tagger/TaggerTestCase.java | 3 +- .../apache/solr/request/TestWriterPerf.java | 3 +- .../SchemaVersionSpecificBehaviorTest.java | 3 +- .../solr/search/RankQueryTestPlugin.java | 3 +- .../solr/search/TestExtendedDismaxParser.java | 3 +- .../mlt/CloudMLTQContentParserTest.java | 3 +- .../solr/search/mlt/CloudMLTQParserTest.java | 3 +- .../solr/security/PrincipalWithUserRoles.java | 3 +- .../update/TestInPlaceUpdatesStandalone.java | 3 +- .../SolrMessageProcessor.java | 6 ++-- ...ctNamedEntitiesUpdateProcessorFactory.java | 6 ++-- .../crossdc/common/MirroredSolrRequest.java | 3 +- .../common/MirroredSolrRequestSerializer.java | 7 ++-- .../extraction/XLSXResponseWriter.java | 6 ++-- .../solr/security/hadoop/KerberosFilter.java | 3 +- .../solr/hdfs/store/HdfsLockFactory.java | 3 +- .../hdfs/store/blockcache/BlockCacheKey.java | 3 +- .../solr/security/jwt/JWTAuthPlugin.java | 9 ++--- .../solr/security/jwt/JWTPrincipal.java | 3 +- .../jwt/JWTPrincipalWithUserRoles.java | 3 +- .../solr/ltr/model/LTRScoringModel.java | 3 +- .../apache/solr/ltr/model/WrapperModel.java | 3 +- .../org/apache/solr/s3/S3StorageClient.java | 3 +- .../solr/handler/sql/CalciteJDBCStream.java | 3 +- .../apache/solr/handler/sql/SolrFilter.java | 15 +++------ .../exporter/MetricsQueryTemplate.java | 3 +- .../client/solrj/io/comp/FieldComparator.java | 9 ++--- .../solr/client/solrj/io/comp/HashKey.java | 3 +- .../io/comp/MultipleFieldComparator.java | 6 ++-- .../client/solrj/io/eq/FieldEqualitor.java | 12 +++---- .../solrj/io/eq/MultipleFieldEqualitor.java | 3 +- .../solrj/io/eval/BicubicSplineEvaluator.java | 3 +- .../solrj/io/eval/ColumnAtEvaluator.java | 3 +- .../solrj/io/eval/ColumnCountEvaluator.java | 3 +- .../solrj/io/eval/CorrelationEvaluator.java | 3 +- .../CorrelationSignificanceEvaluator.java | 6 ++-- .../eval/CumulativeProbabilityEvaluator.java | 3 +- .../solrj/io/eval/DensityEvaluator.java | 4 +-- .../solrj/io/eval/DerivativeEvaluator.java | 4 +-- .../solrj/io/eval/DistanceEvaluator.java | 6 ++-- .../solrj/io/eval/FeatureSelectEvaluator.java | 3 +- .../solrj/io/eval/FieldValueEvaluator.java | 6 ++-- .../solrj/io/eval/GetAmplitudeEvaluator.java | 3 +- .../io/eval/GetAngularFrequencyEvaluator.java | 3 +- .../solrj/io/eval/GetAreaEvaluator.java | 3 +- .../solrj/io/eval/GetAttributeEvaluator.java | 3 +- .../solrj/io/eval/GetAttributesEvaluator.java | 3 +- .../solrj/io/eval/GetBaryCenterEvaluator.java | 3 +- .../io/eval/GetBoundarySizeEvaluator.java | 3 +- .../solrj/io/eval/GetCenterEvaluator.java | 3 +- .../solrj/io/eval/GetCentroidsEvaluator.java | 3 +- .../solrj/io/eval/GetClusterEvaluator.java | 3 +- .../io/eval/GetColumnLabelsEvaluator.java | 3 +- .../io/eval/GetMembershipMatrixEvaluator.java | 3 +- .../solrj/io/eval/GetPhaseEvaluator.java | 3 +- .../solrj/io/eval/GetRadiusEvaluator.java | 3 +- .../solrj/io/eval/GetRowLabelsEvaluator.java | 3 +- .../io/eval/GetSupportPointsEvaluator.java | 3 +- .../solrj/io/eval/GetValueEvaluator.java | 3 +- .../solrj/io/eval/GetVerticesEvaluator.java | 3 +- .../solrj/io/eval/GrandSumEvaluator.java | 3 +- .../client/solrj/io/eval/IFFTEvaluator.java | 3 +- .../solrj/io/eval/IndexOfEvaluator.java | 3 +- .../solrj/io/eval/IntegrateEvaluator.java | 7 ++-- .../io/eval/KolmogorovSmirnovEvaluator.java | 3 +- .../solrj/io/eval/LatLonVectorsEvaluator.java | 3 +- .../solrj/io/eval/LeftShiftEvaluator.java | 3 +- .../solrj/io/eval/MarkovChainEvaluator.java | 3 +- .../io/eval/MatrixMultiplyEvaluator.java | 3 +- .../client/solrj/io/eval/MemsetEvaluator.java | 8 ++--- .../solrj/io/eval/MinMaxScaleEvaluator.java | 3 +- .../solrj/io/eval/MonteCarloEvaluator.java | 3 +- .../solrj/io/eval/MovingAverageEvaluator.java | 3 +- .../solrj/io/eval/MovingMADEvaluator.java | 3 +- .../solrj/io/eval/MovingMedianEvaluator.java | 3 +- .../solrj/io/eval/NormalizeEvaluator.java | 3 +- .../solrj/io/eval/NormalizeSumEvaluator.java | 3 +- .../solrj/io/eval/OutliersEvaluator.java | 7 ++-- .../client/solrj/io/eval/PowerEvaluator.java | 9 ++--- .../solrj/io/eval/PrecisionEvaluator.java | 3 +- .../solrj/io/eval/PredictEvaluator.java | 27 +++++---------- .../solrj/io/eval/ProbabilityEvaluator.java | 15 +++------ .../io/eval/ProjectToBorderEvaluator.java | 6 ++-- .../solrj/io/eval/RecursiveEvaluator.java | 9 ++--- .../io/eval/RecursiveTemporalEvaluator.java | 3 +- .../solrj/io/eval/ReverseEvaluator.java | 3 +- .../solrj/io/eval/RightShiftEvaluator.java | 3 +- .../client/solrj/io/eval/RowAtEvaluator.java | 3 +- .../solrj/io/eval/RowCountEvaluator.java | 3 +- .../client/solrj/io/eval/SampleEvaluator.java | 6 ++-- .../solrj/io/eval/ScalarAddEvaluator.java | 3 +- .../io/eval/SetColumnLabelsEvaluator.java | 3 +- .../solrj/io/eval/SetRowLabelsEvaluator.java | 3 +- .../solrj/io/eval/SetValueEvaluator.java | 3 +- .../solrj/io/eval/SumColumnsEvaluator.java | 3 +- .../solrj/io/eval/SumRowsEvaluator.java | 3 +- .../solrj/io/eval/TermVectorsEvaluator.java | 3 +- .../io/eval/TimeDifferencingEvaluator.java | 3 +- .../solrj/io/eval/TopFeaturesEvaluator.java | 3 +- .../solrj/io/eval/TransposeEvaluator.java | 3 +- .../client/solrj/io/eval/UnitEvaluator.java | 3 +- .../solrj/io/eval/ValueAtEvaluator.java | 3 +- .../solrj/io/graph/GatherNodesStream.java | 3 +- .../client/solrj/io/stream/BiJoinStream.java | 27 +++++---------- .../solrj/io/stream/HashRollupStream.java | 3 +- .../client/solrj/io/stream/JDBCStream.java | 3 +- .../client/solrj/io/stream/LetStream.java | 6 ++-- .../client/solrj/io/stream/ReducerStream.java | 3 +- .../client/solrj/io/stream/RollupStream.java | 3 +- .../solrj/io/stream/ScoreNodesStream.java | 3 +- .../client/solrj/io/stream/TupStream.java | 3 +- .../client/solrj/io/stream/ZplotStream.java | 33 +++++++------------ .../io/stream/expr/StreamExpression.java | 4 +-- .../expr/StreamExpressionNamedParameter.java | 4 +-- .../io/stream/expr/StreamExpressionValue.java | 6 ++-- .../solrj/io/stream/metrics/MaxMetric.java | 6 ++-- .../solrj/io/stream/metrics/MeanMetric.java | 12 +++---- .../solrj/io/stream/metrics/MinMetric.java | 6 ++-- .../solrj/io/stream/metrics/SumMetric.java | 12 +++---- .../io/stream/metrics/WeightedSumMetric.java | 4 +-- .../client/solrj/cloud/VersionedData.java | 3 +- .../client/solrj/impl/NodeValueFetcher.java | 3 +- .../solr/common/cloud/ZkStateReader.java | 4 +-- .../apache/solr/client/solrj/SolrQuery.java | 3 +- .../solrj/beans/DocumentObjectBinder.java | 6 ++-- .../solrj/impl/BinaryRequestWriter.java | 9 ++--- .../solrj/impl/CloudHttp2SolrClient.java | 3 +- .../solrj/impl/CloudLegacySolrClient.java | 3 +- .../client/solrj/impl/CloudSolrClient.java | 18 ++++------ .../impl/ConcurrentUpdateHttp2SolrClient.java | 3 +- .../impl/ConcurrentUpdateSolrClient.java | 3 +- .../solrj/impl/Krb5HttpClientBuilder.java | 3 +- .../solr/client/solrj/impl/LBSolrClient.java | 6 ++-- .../request/JavaBinUpdateRequestCodec.java | 3 +- .../client/solrj/request/RequestWriter.java | 6 ++-- .../solr/client/solrj/request/V2Request.java | 3 +- .../solrj/request/beans/PluginMeta.java | 3 +- .../request/beans/RateLimiterPayload.java | 3 +- .../client/solrj/response/QueryResponse.java | 7 ++-- .../client/solrj/response/Suggestion.java | 4 +-- .../response/json/NestableJsonFacet.java | 4 +-- .../solr/client/solrj/util/ClientUtils.java | 12 +++---- .../apache/solr/common/EnumFieldValue.java | 3 +- .../org/apache/solr/common/SolrDocument.java | 6 ++-- .../org/apache/solr/common/SolrException.java | 3 +- .../apache/solr/common/SolrInputDocument.java | 3 +- .../apache/solr/common/SolrInputField.java | 6 ++-- .../solr/common/ToleratedUpdateError.java | 3 +- .../solr/common/cloud/ClusterState.java | 3 +- .../solr/common/cloud/DocCollection.java | 3 +- .../apache/solr/common/cloud/DocRouter.java | 3 +- .../solr/common/cloud/PerReplicaStates.java | 3 +- .../org/apache/solr/common/cloud/Replica.java | 4 +-- .../org/apache/solr/common/cloud/Slice.java | 3 +- .../util/ByteArrayUtf8CharSequence.java | 5 ++- .../solr/common/util/CommandOperation.java | 9 ++--- .../apache/solr/common/util/JavaBinCodec.java | 6 ++-- .../solr/common/util/JsonSchemaValidator.java | 3 +- .../apache/solr/common/util/NamedList.java | 9 ++--- .../apache/solr/common/util/TextWriter.java | 3 +- .../org/apache/solr/common/util/Utils.java | 6 ++-- .../solr/common/util/ValidatingJsonMap.java | 3 +- .../client/solrj/SolrExampleCborTest.java | 6 ++-- .../solr/client/solrj/SolrExampleTests.java | 14 +++----- .../solr/common/util/TestJavaBinCodec.java | 4 +-- .../solr/BaseDistributedSearchTestCase.java | 9 ++--- .../java/org/apache/solr/JSONTestUtil.java | 3 +- .../java/org/apache/solr/SolrTestCaseJ4.java | 32 ++++++------------ .../cloud/AbstractFullDistribZkTestBase.java | 6 ++-- .../solr/cloud/SolrCloudAuthTestCase.java | 7 ++-- .../placement/ClusterAbstractionsForTest.java | 9 ++--- .../solr/core/MockDirectoryFactory.java | 3 +- .../org/apache/solr/util/TestHarness.java | 3 +- 382 files changed, 621 insertions(+), 1270 deletions(-) diff --git a/build-tools/missing-doclet/src/main/java/org/apache/lucene/missingdoclet/MissingDoclet.java b/build-tools/missing-doclet/src/main/java/org/apache/lucene/missingdoclet/MissingDoclet.java index 44c9c411a9e..8a3c252463c 100644 --- a/build-tools/missing-doclet/src/main/java/org/apache/lucene/missingdoclet/MissingDoclet.java +++ b/build-tools/missing-doclet/src/main/java/org/apache/lucene/missingdoclet/MissingDoclet.java @@ -341,8 +341,7 @@ private boolean hasInheritedJavadocs(Element element) { } // Check for methods up the types tree. - if (element instanceof ExecutableElement) { - ExecutableElement thisMethod = (ExecutableElement) element; + if (element instanceof ExecutableElement thisMethod) { Iterable superTypes = () -> superTypeForInheritDoc(thisMethod.getEnclosingElement()).iterator(); diff --git a/gradle/validation/error-prone.gradle b/gradle/validation/error-prone.gradle index 2acabf4513c..b7242b566c0 100644 --- a/gradle/validation/error-prone.gradle +++ b/gradle/validation/error-prone.gradle @@ -457,7 +457,7 @@ allprojects { prj -> '-Xep:Overrides:WARN', // '-Xep:OverridesGuiceInjectableMethod:OFF', // we don't use guice '-Xep:ParameterName:WARN', - // '-Xep:PatternMatchingInstanceof:WARN', // todo check if useful or comment why not + '-Xep:PatternMatchingInstanceof:WARN', '-Xep:PreconditionsCheckNotNullRepeated:WARN', '-Xep:PrimitiveAtomicReference:WARN', '-Xep:ProtectedMembersInFinalClass:WARN', diff --git a/solr/benchmark/src/java/org/apache/solr/bench/generators/RandomDataHistogram.java b/solr/benchmark/src/java/org/apache/solr/bench/generators/RandomDataHistogram.java index 0f9062331ef..8cd55a7964a 100644 --- a/solr/benchmark/src/java/org/apache/solr/bench/generators/RandomDataHistogram.java +++ b/solr/benchmark/src/java/org/apache/solr/bench/generators/RandomDataHistogram.java @@ -436,8 +436,7 @@ public String toString() { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof Surrogate)) return false; - Surrogate surrogate = (Surrogate) o; + if (!(o instanceof Surrogate surrogate)) return false; return hashCode.equals(surrogate.hashCode) && identityHashcode.equals(surrogate.identityHashcode); } diff --git a/solr/core/src/java/org/apache/solr/api/AnnotatedApi.java b/solr/core/src/java/org/apache/solr/api/AnnotatedApi.java index bfe35c47108..d4c6e454520 100644 --- a/solr/core/src/java/org/apache/solr/api/AnnotatedApi.java +++ b/solr/core/src/java/org/apache/solr/api/AnnotatedApi.java @@ -261,8 +261,7 @@ static class Cmd { } private void readPayloadType(Type t) { - if (t instanceof ParameterizedType) { - ParameterizedType typ = (ParameterizedType) t; + if (t instanceof ParameterizedType typ) { if (typ.getRawType() == PayloadObj.class) { isWrappedInPayloadObj = true; if (typ.getActualTypeArguments().length == 0) { @@ -271,8 +270,7 @@ private void readPayloadType(Type t) { return; } Type t1 = typ.getActualTypeArguments()[0]; - if (t1 instanceof ParameterizedType) { - ParameterizedType parameterizedType = (ParameterizedType) t1; + if (t1 instanceof ParameterizedType parameterizedType) { parameterClass = (Class) parameterizedType.getRawType(); } else { parameterClass = (Class) typ.getActualTypeArguments()[0]; @@ -345,9 +343,8 @@ public int hashCode() { public boolean equals(Object rhs) { if (null == rhs) return false; if (this == rhs) return true; - if (!(rhs instanceof Cmd)) return false; + if (!(rhs instanceof Cmd rhsCast)) return false; - final Cmd rhsCast = (Cmd) rhs; return Objects.equals(command, rhsCast.command) && Objects.equals(method, rhsCast.method) && Objects.equals(obj, rhsCast.obj) @@ -373,8 +370,7 @@ public static Map createSchema(Method m) { t = types[2]; // (SolrQueryRequest req, SolrQueryResponse rsp, PayloadObj) if (types.length == 1) t = types[0]; // (PayloadObj) if (t != null) { - if (t instanceof ParameterizedType) { - ParameterizedType typ = (ParameterizedType) t; + if (t instanceof ParameterizedType typ) { if (typ.getRawType() == PayloadObj.class) { t = typ.getActualTypeArguments()[0]; } diff --git a/solr/core/src/java/org/apache/solr/api/ApiBag.java b/solr/core/src/java/org/apache/solr/api/ApiBag.java index 48359f783b1..1d9a6d2a80d 100644 --- a/solr/core/src/java/org/apache/solr/api/ApiBag.java +++ b/solr/core/src/java/org/apache/solr/api/ApiBag.java @@ -122,16 +122,14 @@ protected void attachValueToNode(PathTrie.Node node, Api o) { // If 'o' and 'node.obj' aren't both AnnotatedApi's then we can't aggregate the commands, so // fallback to the default behavior - if ((!(o instanceof AnnotatedApi)) || (!(node.getObject() instanceof AnnotatedApi))) { + if ((!(o instanceof AnnotatedApi beingRegistered)) + || (!(node.getObject() instanceof AnnotatedApi alreadyRegistered))) { super.attachValueToNode(node, o); return; } - final AnnotatedApi beingRegistered = (AnnotatedApi) o; - final AnnotatedApi alreadyRegistered = (AnnotatedApi) node.getObject(); - if (alreadyRegistered instanceof CommandAggregatingAnnotatedApi) { - final CommandAggregatingAnnotatedApi alreadyRegisteredAsCollapsing = - (CommandAggregatingAnnotatedApi) alreadyRegistered; + if (alreadyRegistered + instanceof CommandAggregatingAnnotatedApi alreadyRegisteredAsCollapsing) { alreadyRegisteredAsCollapsing.combineWith(beingRegistered); } else { final CommandAggregatingAnnotatedApi wrapperApi = @@ -404,11 +402,10 @@ public void registerLazy(PluginBag.PluginHolder holder, Plug public static SpecProvider constructSpec(PluginInfo info) { Object specObj = info == null ? null : info.attributes.get("spec"); - if (specObj != null && specObj instanceof Map) { + if (specObj != null && specObj instanceof Map map) { // Value from Map can be a Map because in PluginInfo(String, Map) we assign a // Map // assert false : "got a map when this should only be Strings"; - Map map = (Map) specObj; return () -> ValidatingJsonMap.getDeepCopy(map, 4, false); } else { return HANDLER_NAME_SPEC_PROVIDER; diff --git a/solr/core/src/java/org/apache/solr/api/ContainerPluginsRegistry.java b/solr/core/src/java/org/apache/solr/api/ContainerPluginsRegistry.java index 4573a6e550e..20cd2440bbe 100644 --- a/solr/core/src/java/org/apache/solr/api/ContainerPluginsRegistry.java +++ b/solr/core/src/java/org/apache/solr/api/ContainerPluginsRegistry.java @@ -158,8 +158,7 @@ static class PluginMetaHolder { @Override public boolean equals(Object obj) { - if (obj instanceof PluginMetaHolder) { - PluginMetaHolder that = (PluginMetaHolder) obj; + if (obj instanceof PluginMetaHolder that) { return Objects.equals(this.original, that.original); } return false; @@ -466,8 +465,7 @@ public static Class getConfigClass(ConfigurablePlugin list = (List) field; + if (field instanceof List list) { if (hasdate(list)) { ArrayList listCopy = new ArrayList<>(list.size()); for (Object o : list) listCopy.add(constructDateStr(o)); @@ -443,8 +442,7 @@ public synchronized void accept(SolrDocument doc) throws IOException { } } field = constructDateStr(field); - if (field instanceof List) { - List list = (List) field; + if (field instanceof List list) { if (hasdate(list)) { ArrayList listCopy = new ArrayList<>(list.size()); for (Object o : list) listCopy.add(constructDateStr(o)); diff --git a/solr/core/src/java/org/apache/solr/cli/HealthcheckTool.java b/solr/core/src/java/org/apache/solr/cli/HealthcheckTool.java index 8a6b293e17a..950ac3430b9 100644 --- a/solr/core/src/java/org/apache/solr/cli/HealthcheckTool.java +++ b/solr/core/src/java/org/apache/solr/cli/HealthcheckTool.java @@ -286,8 +286,7 @@ public int hashCode() { public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; - if (!(obj instanceof ReplicaHealth)) return true; - ReplicaHealth that = (ReplicaHealth) obj; + if (!(obj instanceof ReplicaHealth that)) return true; return this.shard.equals(that.shard) && this.isLeader == that.isLeader; } diff --git a/solr/core/src/java/org/apache/solr/cli/StreamTool.java b/solr/core/src/java/org/apache/solr/cli/StreamTool.java index fba6c91809d..6cb6ae81dbb 100644 --- a/solr/core/src/java/org/apache/solr/cli/StreamTool.java +++ b/solr/core/src/java/org/apache/solr/cli/StreamTool.java @@ -217,8 +217,7 @@ public void runImpl(CommandLine cli) throws Exception { Object o = tuple.get(outputHeaders[i]); if (o != null) { - if (o instanceof List) { - List outfields = (List) o; + if (o instanceof List outfields) { outLine.append(listToString(outfields, arrayDelimiter)); } else { outLine.append(o); diff --git a/solr/core/src/java/org/apache/solr/client/solrj/embedded/EmbeddedSolrServer.java b/solr/core/src/java/org/apache/solr/client/solrj/embedded/EmbeddedSolrServer.java index 1da77d8db82..a15195f6228 100644 --- a/solr/core/src/java/org/apache/solr/client/solrj/embedded/EmbeddedSolrServer.java +++ b/solr/core/src/java/org/apache/solr/client/solrj/embedded/EmbeddedSolrServer.java @@ -321,8 +321,7 @@ public void writeResults(ResultContext ctx, JavaBinCodec codec) throws IOExcepti /** A list of streams, non-null. */ private List getContentStreams(SolrRequest request) throws IOException { if (request.getMethod() == SolrRequest.METHOD.GET) return List.of(); - if (request instanceof ContentStreamUpdateRequest) { - final ContentStreamUpdateRequest csur = (ContentStreamUpdateRequest) request; + if (request instanceof ContentStreamUpdateRequest csur) { final Collection cs = csur.getContentStreams(); if (cs != null) return new ArrayList<>(cs); } diff --git a/solr/core/src/java/org/apache/solr/cloud/Overseer.java b/solr/core/src/java/org/apache/solr/cloud/Overseer.java index 378b2ff7043..8546bb7adad 100644 --- a/solr/core/src/java/org/apache/solr/cloud/Overseer.java +++ b/solr/core/src/java/org/apache/solr/cloud/Overseer.java @@ -423,8 +423,7 @@ public void run() { // Return true whenever the exception thrown by ZkStateWriter is correspond // to a invalid state or 'bad' message (in this case, we should remove that message from queue) private boolean isBadMessage(Exception e) { - if (e instanceof KeeperException) { - KeeperException ke = (KeeperException) e; + if (e instanceof KeeperException ke) { return ke.code() == KeeperException.Code.NONODE || ke.code() == KeeperException.Code.NODEEXISTS; } diff --git a/solr/core/src/java/org/apache/solr/cloud/OverseerTaskQueue.java b/solr/core/src/java/org/apache/solr/cloud/OverseerTaskQueue.java index 3092dce185e..c79b1d40ff9 100644 --- a/solr/core/src/java/org/apache/solr/cloud/OverseerTaskQueue.java +++ b/solr/core/src/java/org/apache/solr/cloud/OverseerTaskQueue.java @@ -318,8 +318,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { if (this == obj) return true; - if (!(obj instanceof QueueEvent)) return false; - QueueEvent other = (QueueEvent) obj; + if (!(obj instanceof QueueEvent other)) return false; return Objects.equals(id, other.id); } diff --git a/solr/core/src/java/org/apache/solr/cloud/RecoveringCoreTermWatcher.java b/solr/core/src/java/org/apache/solr/cloud/RecoveringCoreTermWatcher.java index 1821600fc83..6bba8e99319 100644 --- a/solr/core/src/java/org/apache/solr/cloud/RecoveringCoreTermWatcher.java +++ b/solr/core/src/java/org/apache/solr/cloud/RecoveringCoreTermWatcher.java @@ -76,9 +76,8 @@ public boolean onTermChanged(ShardTerms terms) { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof RecoveringCoreTermWatcher)) return false; + if (!(o instanceof RecoveringCoreTermWatcher that)) return false; - RecoveringCoreTermWatcher that = (RecoveringCoreTermWatcher) o; return coreDescriptor.getName().equals(that.coreDescriptor.getName()); } diff --git a/solr/core/src/java/org/apache/solr/cloud/ZkController.java b/solr/core/src/java/org/apache/solr/cloud/ZkController.java index 5cb313f717a..76f9618d4b1 100644 --- a/solr/core/src/java/org/apache/solr/cloud/ZkController.java +++ b/solr/core/src/java/org/apache/solr/cloud/ZkController.java @@ -180,8 +180,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { if (this == obj) return true; - if (!(obj instanceof ContextKey)) return false; - ContextKey other = (ContextKey) obj; + if (!(obj instanceof ContextKey other)) return false; return Objects.equals(collection, other.collection) && Objects.equals(coreNodeName, other.coreNodeName); } @@ -2833,8 +2832,7 @@ public synchronized boolean onStateChanged(DocCollection collectionState) { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof UnloadCoreOnDeletedWatcher)) return false; - UnloadCoreOnDeletedWatcher that = (UnloadCoreOnDeletedWatcher) o; + if (!(o instanceof UnloadCoreOnDeletedWatcher that)) return false; return Objects.equals(coreNodeName, that.coreNodeName) && Objects.equals(shard, that.shard) && Objects.equals(coreName, that.coreName); diff --git a/solr/core/src/java/org/apache/solr/cloud/api/collections/MigrateCmd.java b/solr/core/src/java/org/apache/solr/cloud/api/collections/MigrateCmd.java index 95d1eb2ac11..b09f806535a 100644 --- a/solr/core/src/java/org/apache/solr/cloud/api/collections/MigrateCmd.java +++ b/solr/core/src/java/org/apache/solr/cloud/api/collections/MigrateCmd.java @@ -101,11 +101,11 @@ public void call(ClusterState clusterState, ZkNodeProps message, NamedList sourceSlices = sourceRouter.getSearchSlicesSingle(splitKey, null, sourceCollection); if (sourceSlices.isEmpty()) { diff --git a/solr/core/src/java/org/apache/solr/cloud/api/collections/RoutedAlias.java b/solr/core/src/java/org/apache/solr/cloud/api/collections/RoutedAlias.java index d41eed3611d..7dec30d1a8d 100644 --- a/solr/core/src/java/org/apache/solr/cloud/api/collections/RoutedAlias.java +++ b/solr/core/src/java/org/apache/solr/cloud/api/collections/RoutedAlias.java @@ -490,8 +490,7 @@ public Action(RoutedAlias sourceAlias, ActionType actionType, String targetColle @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof Action)) return false; - Action action = (Action) o; + if (!(o instanceof Action action)) return false; return Objects.equals(sourceAlias, action.sourceAlias) && actionType == action.actionType && Objects.equals(targetCollection, action.targetCollection); diff --git a/solr/core/src/java/org/apache/solr/cloud/api/collections/SplitShardCmd.java b/solr/core/src/java/org/apache/solr/cloud/api/collections/SplitShardCmd.java index 355d03ae7e2..c5ef5649a22 100644 --- a/solr/core/src/java/org/apache/solr/cloud/api/collections/SplitShardCmd.java +++ b/solr/core/src/java/org/apache/solr/cloud/api/collections/SplitShardCmd.java @@ -1126,8 +1126,7 @@ public static String fillRanges( } } } else if (splitKey != null) { - if (router instanceof CompositeIdRouter) { - CompositeIdRouter compositeIdRouter = (CompositeIdRouter) router; + if (router instanceof CompositeIdRouter compositeIdRouter) { List tmpSubRanges = compositeIdRouter.partitionRangeByKey(splitKey, range); if (tmpSubRanges.size() == 1) { throw new SolrException( diff --git a/solr/core/src/java/org/apache/solr/cloud/overseer/SliceMutator.java b/solr/core/src/java/org/apache/solr/cloud/overseer/SliceMutator.java index d5170c66474..66af10548a8 100644 --- a/solr/core/src/java/org/apache/solr/cloud/overseer/SliceMutator.java +++ b/solr/core/src/java/org/apache/solr/cloud/overseer/SliceMutator.java @@ -62,8 +62,7 @@ public SliceMutator(SolrCloudManager cloudManager) { } static SolrZkClient getZkClient(SolrCloudManager cloudManager) { - if (cloudManager instanceof SolrClientCloudManager) { - SolrClientCloudManager manager = (SolrClientCloudManager) cloudManager; + if (cloudManager instanceof SolrClientCloudManager manager) { return manager.getZkClient(); } else { return null; diff --git a/solr/core/src/java/org/apache/solr/cluster/events/impl/ClusterEventProducerFactory.java b/solr/core/src/java/org/apache/solr/cluster/events/impl/ClusterEventProducerFactory.java index a022f9c20c4..e7401940ad7 100644 --- a/solr/core/src/java/org/apache/solr/cluster/events/impl/ClusterEventProducerFactory.java +++ b/solr/core/src/java/org/apache/solr/cluster/events/impl/ClusterEventProducerFactory.java @@ -133,8 +133,7 @@ public void added(ContainerPluginsRegistry.ApiInfo plugin) { return; } Object instance = plugin.getInstance(); - if (instance instanceof ClusterEventListener) { - ClusterEventListener listener = (ClusterEventListener) instance; + if (instance instanceof ClusterEventListener listener) { clusterEventProducer.registerListener(listener); } else if (instance instanceof ClusterEventProducer) { if (ClusterEventProducer.PLUGIN_NAME.equals(plugin.getInfo().name)) { @@ -162,8 +161,7 @@ public void deleted(ContainerPluginsRegistry.ApiInfo plugin) { return; } Object instance = plugin.getInstance(); - if (instance instanceof ClusterEventListener) { - ClusterEventListener listener = (ClusterEventListener) instance; + if (instance instanceof ClusterEventListener listener) { clusterEventProducer.unregisterListener(listener); } else if (instance instanceof ClusterEventProducer) { if (ClusterEventProducer.PLUGIN_NAME.equals(plugin.getInfo().name)) { diff --git a/solr/core/src/java/org/apache/solr/cluster/placement/impl/MetricImpl.java b/solr/core/src/java/org/apache/solr/cluster/placement/impl/MetricImpl.java index caee316952c..b84c2892186 100644 --- a/solr/core/src/java/org/apache/solr/cluster/placement/impl/MetricImpl.java +++ b/solr/core/src/java/org/apache/solr/cluster/placement/impl/MetricImpl.java @@ -115,10 +115,9 @@ public boolean equals(Object o) { if (this == o) { return true; } - if (!(o instanceof MetricImpl)) { + if (!(o instanceof MetricImpl that)) { return false; } - MetricImpl that = (MetricImpl) o; return name.equals(that.getName()) && internalName.equals(that.getInternalName()) && converter.equals(that.converter); diff --git a/solr/core/src/java/org/apache/solr/cluster/placement/impl/NodeMetricImpl.java b/solr/core/src/java/org/apache/solr/cluster/placement/impl/NodeMetricImpl.java index b76013d1903..cdf1fcb93fc 100644 --- a/solr/core/src/java/org/apache/solr/cluster/placement/impl/NodeMetricImpl.java +++ b/solr/core/src/java/org/apache/solr/cluster/placement/impl/NodeMetricImpl.java @@ -88,13 +88,12 @@ public boolean equals(Object o) { if (this == o) { return true; } - if (!(o instanceof NodeMetricImpl)) { + if (!(o instanceof NodeMetricImpl that)) { return false; } if (!super.equals(o)) { return false; } - NodeMetricImpl that = (NodeMetricImpl) o; return registry == that.registry; } diff --git a/solr/core/src/java/org/apache/solr/cluster/placement/impl/SimpleClusterAbstractionsImpl.java b/solr/core/src/java/org/apache/solr/cluster/placement/impl/SimpleClusterAbstractionsImpl.java index ece890b9b1f..b518c37c5a3 100644 --- a/solr/core/src/java/org/apache/solr/cluster/placement/impl/SimpleClusterAbstractionsImpl.java +++ b/solr/core/src/java/org/apache/solr/cluster/placement/impl/SimpleClusterAbstractionsImpl.java @@ -139,10 +139,9 @@ public boolean equals(Object obj) { if (obj == this) { return true; } - if (!(obj instanceof NodeImpl)) { + if (!(obj instanceof NodeImpl other)) { return false; } - NodeImpl other = (NodeImpl) obj; return Objects.equals(this.nodeName, other.nodeName); } @@ -307,10 +306,9 @@ public boolean equals(Object obj) { if (obj == this) { return true; } - if (!(obj instanceof ShardImpl)) { + if (!(obj instanceof ShardImpl other)) { return false; } - ShardImpl other = (ShardImpl) obj; return Objects.equals(this.shardName, other.shardName) && Objects.equals(this.collection, other.collection) && Objects.equals(this.shardState, other.shardState) @@ -467,10 +465,9 @@ public boolean equals(Object obj) { if (obj == this) { return true; } - if (!(obj instanceof ReplicaImpl)) { + if (!(obj instanceof ReplicaImpl other)) { return false; } - ReplicaImpl other = (ReplicaImpl) obj; return Objects.equals(this.replicaName, other.replicaName) && Objects.equals(this.coreName, other.coreName) && Objects.equals(this.shard, other.shard) diff --git a/solr/core/src/java/org/apache/solr/cluster/placement/plugins/OrderedNodePlacementPlugin.java b/solr/core/src/java/org/apache/solr/cluster/placement/plugins/OrderedNodePlacementPlugin.java index 86ca79526b3..a353b9dd5e2 100644 --- a/solr/core/src/java/org/apache/solr/cluster/placement/plugins/OrderedNodePlacementPlugin.java +++ b/solr/core/src/java/org/apache/solr/cluster/placement/plugins/OrderedNodePlacementPlugin.java @@ -555,10 +555,9 @@ public int hashCode() { @Override public boolean equals(Object o) { - if (!(o instanceof WeightedNode)) { + if (!(o instanceof WeightedNode on)) { return false; } else { - WeightedNode on = (WeightedNode) o; if (this.node == null) { return on.node == null; } else { diff --git a/solr/core/src/java/org/apache/solr/core/ClusterSingletons.java b/solr/core/src/java/org/apache/solr/core/ClusterSingletons.java index 0c71c853400..f8f41a58e29 100644 --- a/solr/core/src/java/org/apache/solr/core/ClusterSingletons.java +++ b/solr/core/src/java/org/apache/solr/core/ClusterSingletons.java @@ -69,8 +69,7 @@ public void added(ContainerPluginsRegistry.ApiInfo plugin) { } // register new api Object instance = plugin.getInstance(); - if (instance instanceof ClusterSingleton) { - ClusterSingleton singleton = (ClusterSingleton) instance; + if (instance instanceof ClusterSingleton singleton) { singletonMap.put(singleton.getName(), singleton); // check to see if we should immediately start this singleton if (isReady() && runSingletons.get()) { @@ -89,8 +88,7 @@ public void deleted(ContainerPluginsRegistry.ApiInfo plugin) { return; } Object instance = plugin.getInstance(); - if (instance instanceof ClusterSingleton) { - ClusterSingleton singleton = (ClusterSingleton) instance; + if (instance instanceof ClusterSingleton singleton) { singleton.stop(); singletonMap.remove(singleton.getName()); } diff --git a/solr/core/src/java/org/apache/solr/core/ConfigOverlay.java b/solr/core/src/java/org/apache/solr/core/ConfigOverlay.java index 403501c19f8..811ea865cd6 100644 --- a/solr/core/src/java/org/apache/solr/core/ConfigOverlay.java +++ b/solr/core/src/java/org/apache/solr/core/ConfigOverlay.java @@ -193,8 +193,7 @@ private static Class isEditable(boolean isXpath, List hierarchy, List if (hierarchy != null) hierarchy.add(part); if (obj == null) return null; if (i == parts.size() - 1) { - if (obj instanceof Map) { - Map map = (Map) obj; + if (obj instanceof Map map) { Object o = map.get(part); return checkType(o, isXpath, isAttr); } @@ -209,8 +208,7 @@ private static Class isEditable(boolean isXpath, List hierarchy, List new Class[] {String.class, Boolean.class, Integer.class, Float.class}; private static Class checkType(Object o, boolean isXpath, boolean isAttr) { - if (o instanceof Long) { - Long aLong = (Long) o; + if (o instanceof Long aLong) { int ten = aLong.intValue() / 10; int one = aLong.intValue() % 10; if (isXpath && isAttr && one != 0) return null; diff --git a/solr/core/src/java/org/apache/solr/core/CoreContainer.java b/solr/core/src/java/org/apache/solr/core/CoreContainer.java index 69b6f07fb47..46c584750cb 100644 --- a/solr/core/src/java/org/apache/solr/core/CoreContainer.java +++ b/solr/core/src/java/org/apache/solr/core/CoreContainer.java @@ -594,9 +594,8 @@ private synchronized void initializeAuthenticationPlugin( } private void setupHttpClientForAuthPlugin(Object authcPlugin) { - if (authcPlugin instanceof HttpClientBuilderPlugin) { + if (authcPlugin instanceof HttpClientBuilderPlugin builderPlugin) { // Setup HttpClient for internode communication - HttpClientBuilderPlugin builderPlugin = ((HttpClientBuilderPlugin) authcPlugin); SolrHttpClientBuilder builder = builderPlugin.getHttpClientBuilder(HttpClientUtil.getHttpClientBuilder()); @@ -824,8 +823,7 @@ private void loadInternal() { shardHandlerFactory = ShardHandlerFactory.newInstance(cfg.getShardHandlerFactoryPluginInfo(), loader); - if (shardHandlerFactory instanceof SolrMetricProducer) { - SolrMetricProducer metricProducer = (SolrMetricProducer) shardHandlerFactory; + if (shardHandlerFactory instanceof SolrMetricProducer metricProducer) { metricProducer.initializeMetrics(solrMetricsContext, "httpShardHandler"); } @@ -1129,8 +1127,7 @@ private void loadInternal() { .forEach( handlerName -> { SolrRequestHandler handler = containerHandlers.get(handlerName); - if (handler instanceof ClusterSingleton) { - ClusterSingleton singleton = (ClusterSingleton) handler; + if (handler instanceof ClusterSingleton singleton) { clusterSingletons.getSingletons().put(singleton.getName(), singleton); } }); diff --git a/solr/core/src/java/org/apache/solr/core/CoreSorter.java b/solr/core/src/java/org/apache/solr/core/CoreSorter.java index b62167c5ec7..a21e64948e9 100644 --- a/solr/core/src/java/org/apache/solr/core/CoreSorter.java +++ b/solr/core/src/java/org/apache/solr/core/CoreSorter.java @@ -157,8 +157,7 @@ public String toString() { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof CountsForEachShard)) return false; - CountsForEachShard that = (CountsForEachShard) o; + if (!(o instanceof CountsForEachShard that)) return false; return totalReplicasInDownNodes == that.totalReplicasInDownNodes && myReplicas == that.myReplicas && totalReplicasInLiveNodes == that.totalReplicasInLiveNodes; diff --git a/solr/core/src/java/org/apache/solr/core/PluginBag.java b/solr/core/src/java/org/apache/solr/core/PluginBag.java index 629c480d5ce..7624a4c13dd 100644 --- a/solr/core/src/java/org/apache/solr/core/PluginBag.java +++ b/solr/core/src/java/org/apache/solr/core/PluginBag.java @@ -239,8 +239,7 @@ public PluginHolder put(String name, PluginHolder plugin) { if (loadV2ApisIfPresent) { if (plugin.isLoaded()) { T inst = plugin.get(); - if (inst instanceof ApiSupport) { - ApiSupport apiSupport = (ApiSupport) inst; + if (inst instanceof ApiSupport apiSupport) { if (registerApi == null) registerApi = apiSupport.registerV2(); if (disableHandler == null) disableHandler = !apiSupport.registerV1(); @@ -366,8 +365,7 @@ public boolean isLoaded(String name) { private void registerMBean(Object inst, SolrCore core, String pluginKey) { if (core == null) return; - if (inst instanceof SolrInfoBean) { - SolrInfoBean mBean = (SolrInfoBean) inst; + if (inst instanceof SolrInfoBean mBean) { String name = (inst instanceof SolrRequestHandler) ? pluginKey : mBean.getName(); core.registerInfoBean(name, mBean); } diff --git a/solr/core/src/java/org/apache/solr/core/PluginInfo.java b/solr/core/src/java/org/apache/solr/core/PluginInfo.java index 5c24ee9a8f4..c091beea08e 100644 --- a/solr/core/src/java/org/apache/solr/core/PluginInfo.java +++ b/solr/core/src/java/org/apache/solr/core/PluginInfo.java @@ -142,8 +142,7 @@ public PluginInfo(String type, Map map) { for (Map.Entry entry : map.entrySet()) { if (NAME.equals(entry.getKey()) || CLASS_NAME.equals(entry.getKey())) continue; Object value = entry.getValue(); - if (value instanceof List) { - List list = (List) value; + if (value instanceof List list) { if (!list.isEmpty() && list.get(0) instanceof Map) { // this is a subcomponent for (Object o : list) { if (o instanceof Map) o = new NamedList<>((Map) o); @@ -234,8 +233,7 @@ public Map toMap(Map map) { Object old = m.get(child.name); if (old == null) { m.put(child.name, child.toMap(new LinkedHashMap<>())); - } else if (old instanceof List) { - List list = (List) old; + } else if (old instanceof List list) { list.add(child.toMap(new LinkedHashMap<>())); } else { ArrayList l = new ArrayList(); diff --git a/solr/core/src/java/org/apache/solr/core/QuerySenderListener.java b/solr/core/src/java/org/apache/solr/core/QuerySenderListener.java index a612b27809a..dd7b679b685 100644 --- a/solr/core/src/java/org/apache/solr/core/QuerySenderListener.java +++ b/solr/core/src/java/org/apache/solr/core/QuerySenderListener.java @@ -82,13 +82,11 @@ public void close() {} for (int i = 0; i < values.size(); i++) { Object o = values.getVal(i); SolrDocumentFetcher docFetcher = null; - if (o instanceof ResultContext) { - ResultContext ctx = (ResultContext) o; + if (o instanceof ResultContext ctx) { o = ctx.getDocList(); docFetcher = ctx.getDocFetcher(); } - if (o instanceof DocList) { - DocList docs = (DocList) o; + if (o instanceof DocList docs) { if (docFetcher == null) { docFetcher = newSearcher.getDocFetcher(); } diff --git a/solr/core/src/java/org/apache/solr/core/RequestParams.java b/solr/core/src/java/org/apache/solr/core/RequestParams.java index e5937d0856d..e480de4bfb5 100644 --- a/solr/core/src/java/org/apache/solr/core/RequestParams.java +++ b/solr/core/src/java/org/apache/solr/core/RequestParams.java @@ -52,8 +52,7 @@ public RequestParams(Map data, int znodeVersion) { Map paramsets = (Map) data.get(NAME); if (paramsets != null) { for (Map.Entry e : paramsets.entrySet()) { - if (e.getValue() instanceof Map) { - Map value = (Map) e.getValue(); + if (e.getValue() instanceof Map value) { this.paramsets.put((String) e.getKey(), createParamSet(value, 0l)); } } @@ -87,8 +86,7 @@ private static Map getMapCopy(Map value) { } } else if (entry.getValue() == null) { copy.put(entry.getKey(), null); - } else if (entry.getValue() instanceof List) { - List l = (List) entry.getValue(); + } else if (entry.getValue() instanceof List l) { String[] sarr = new String[l.size()]; for (int i = 0; i < l.size(); i++) { if (l.get(i) != null) sarr[i] = String.valueOf(l.get(i)); @@ -138,8 +136,7 @@ public RequestParams setParams(String name, ParamSet paramSet) { public static RequestParams getFreshRequestParams( SolrResourceLoader loader, RequestParams requestParams) { - if (loader instanceof ZkSolrResourceLoader) { - ZkSolrResourceLoader resourceLoader = (ZkSolrResourceLoader) loader; + if (loader instanceof ZkSolrResourceLoader resourceLoader) { try { Stat stat = resourceLoader diff --git a/solr/core/src/java/org/apache/solr/core/SchemaCodecFactory.java b/solr/core/src/java/org/apache/solr/core/SchemaCodecFactory.java index 9c52f912784..a7d9305b3c3 100644 --- a/solr/core/src/java/org/apache/solr/core/SchemaCodecFactory.java +++ b/solr/core/src/java/org/apache/solr/core/SchemaCodecFactory.java @@ -126,8 +126,7 @@ public DocValuesFormat getDocValuesFormatForField(String field) { public KnnVectorsFormat getKnnVectorsFormatForField(String field) { final SchemaField schemaField = core.getLatestSchema().getFieldOrNull(field); FieldType fieldType = (schemaField == null ? null : schemaField.getType()); - if (fieldType instanceof DenseVectorField) { - DenseVectorField vectorType = (DenseVectorField) fieldType; + if (fieldType instanceof DenseVectorField vectorType) { String knnAlgorithm = vectorType.getKnnAlgorithm(); if (DenseVectorField.HNSW_ALGORITHM.equals(knnAlgorithm)) { int maxConn = vectorType.getHnswMaxConn(); diff --git a/solr/core/src/java/org/apache/solr/core/SolrConfig.java b/solr/core/src/java/org/apache/solr/core/SolrConfig.java index 173a44b9ba2..b3c95a23fe7 100644 --- a/solr/core/src/java/org/apache/solr/core/SolrConfig.java +++ b/solr/core/src/java/org/apache/solr/core/SolrConfig.java @@ -173,14 +173,11 @@ private class ResourceProvider implements Function { ResourceProvider(InputStream in) throws IOException { this.in = in; - if (in instanceof ZkSolrResourceLoader.ZkByteArrayInputStream) { - ZkSolrResourceLoader.ZkByteArrayInputStream zkin = - (ZkSolrResourceLoader.ZkByteArrayInputStream) in; + if (in instanceof ZkSolrResourceLoader.ZkByteArrayInputStream zkin) { zkVersion = zkin.getStat().getVersion(); hash = Objects.hash(zkin.getStat().getCtime(), zkVersion, overlay.getVersion()); this.fileName = zkin.fileName; - } else if (in instanceof SolrResourceLoader.SolrFileInputStream) { - SolrResourceLoader.SolrFileInputStream sfin = (SolrResourceLoader.SolrFileInputStream) in; + } else if (in instanceof SolrResourceLoader.SolrFileInputStream sfin) { zkVersion = (int) sfin.getLastModified(); hash = Objects.hash(sfin.getLastModified(), overlay.getVersion()); } diff --git a/solr/core/src/java/org/apache/solr/core/SolrCore.java b/solr/core/src/java/org/apache/solr/core/SolrCore.java index f56cb846767..55325568abe 100644 --- a/solr/core/src/java/org/apache/solr/core/SolrCore.java +++ b/solr/core/src/java/org/apache/solr/core/SolrCore.java @@ -949,8 +949,7 @@ public static T createInstance( } catch (Exception e) { // The JVM likes to wrap our helpful SolrExceptions in things like // "InvocationTargetException" that have no useful getMessage - if (null != e.getCause() && e.getCause() instanceof SolrException) { - SolrException inner = (SolrException) e.getCause(); + if (null != e.getCause() && e.getCause() instanceof SolrException inner) { throw inner; } @@ -995,8 +994,7 @@ private UpdateHandler createReloadedUpdateHandler( } catch (Exception e) { // The JVM likes to wrap our helpful SolrExceptions in things like // "InvocationTargetException" that have no useful getMessage - if (null != e.getCause() && e.getCause() instanceof SolrException) { - SolrException inner = (SolrException) e.getCause(); + if (null != e.getCause() && e.getCause() instanceof SolrException inner) { throw inner; } @@ -3392,8 +3390,7 @@ public boolean removeConfListener(Runnable runnable) { * some data so that events are triggered. */ private void registerConfListener() { - if (!(resourceLoader instanceof ZkSolrResourceLoader)) return; - final ZkSolrResourceLoader zkSolrResourceLoader = (ZkSolrResourceLoader) resourceLoader; + if (!(resourceLoader instanceof ZkSolrResourceLoader zkSolrResourceLoader)) return; if (zkSolrResourceLoader != null) zkSolrResourceLoader .getZkController() @@ -3413,8 +3410,7 @@ public static Runnable getConfListener(SolrCore core, ZkSolrResourceLoader zkSol zkSolrResourceLoader.getConfigSetZkPath() + "/" + core.getSolrConfig().getName(); String schemaRes = null; if (core.getLatestSchema().isMutable() - && core.getLatestSchema() instanceof ManagedIndexSchema) { - ManagedIndexSchema mis = (ManagedIndexSchema) core.getLatestSchema(); + && core.getLatestSchema() instanceof ManagedIndexSchema mis) { schemaRes = mis.getResourceName(); } final String managedSchemaResourcePath = diff --git a/solr/core/src/java/org/apache/solr/core/SolrDeletionPolicy.java b/solr/core/src/java/org/apache/solr/core/SolrDeletionPolicy.java index 2b8232deef0..bf4f5072b8d 100644 --- a/solr/core/src/java/org/apache/solr/core/SolrDeletionPolicy.java +++ b/solr/core/src/java/org/apache/solr/core/SolrDeletionPolicy.java @@ -113,8 +113,7 @@ public final String toString() { protected void appendDetails(StringBuilder sb, IndexCommit c) { Directory dir = c.getDirectory(); - if (dir instanceof FSDirectory) { - FSDirectory fsd = (FSDirectory) dir; + if (dir instanceof FSDirectory fsd) { sb.append("dir=").append(fsd.getDirectory()); } else { sb.append("dir=").append(dir); @@ -198,8 +197,7 @@ private String getId(IndexCommit commit) { // For anything persistent, make something that will // be the same, regardless of the Directory instance. - if (dir instanceof FSDirectory) { - FSDirectory fsd = (FSDirectory) dir; + if (dir instanceof FSDirectory fsd) { File fdir = fsd.getDirectory().toFile(); sb.append(fdir.getPath()); } else { diff --git a/solr/core/src/java/org/apache/solr/core/SolrXmlConfig.java b/solr/core/src/java/org/apache/solr/core/SolrXmlConfig.java index b19d65320ad..da4df722c59 100644 --- a/solr/core/src/java/org/apache/solr/core/SolrXmlConfig.java +++ b/solr/core/src/java/org/apache/solr/core/SolrXmlConfig.java @@ -760,8 +760,7 @@ private static Map getCachesConfig( } private static Object decodeNullValue(Object o) { - if (o instanceof String) { // check if it's a JSON object - String str = (String) o; + if (o instanceof String str) { // check if it's a JSON object if (!str.isBlank() && (str.startsWith("{") || str.startsWith("["))) { try { o = Utils.fromJSONString((String) o); diff --git a/solr/core/src/java/org/apache/solr/core/backup/BackupId.java b/solr/core/src/java/org/apache/solr/core/backup/BackupId.java index 3effa11b4e8..e5e335609cd 100644 --- a/solr/core/src/java/org/apache/solr/core/backup/BackupId.java +++ b/solr/core/src/java/org/apache/solr/core/backup/BackupId.java @@ -62,8 +62,7 @@ public int compareTo(BackupId o) { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof BackupId)) return false; - BackupId backupId = (BackupId) o; + if (!(o instanceof BackupId backupId)) return false; return id == backupId.id; } diff --git a/solr/core/src/java/org/apache/solr/core/backup/Checksum.java b/solr/core/src/java/org/apache/solr/core/backup/Checksum.java index 888c6489b1d..1d57d72ff7d 100644 --- a/solr/core/src/java/org/apache/solr/core/backup/Checksum.java +++ b/solr/core/src/java/org/apache/solr/core/backup/Checksum.java @@ -32,9 +32,8 @@ public Checksum(long checksum, long size) { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof Checksum)) return false; - Checksum checksum = (Checksum) o; - return size == checksum.size && this.checksum == checksum.checksum; + if (!(o instanceof Checksum cs)) return false; + return size == cs.size && this.checksum == cs.checksum; } @Override diff --git a/solr/core/src/java/org/apache/solr/core/backup/repository/BackupRepositoryFactory.java b/solr/core/src/java/org/apache/solr/core/backup/repository/BackupRepositoryFactory.java index c838ebd4185..d699d2005d5 100644 --- a/solr/core/src/java/org/apache/solr/core/backup/repository/BackupRepositoryFactory.java +++ b/solr/core/src/java/org/apache/solr/core/backup/repository/BackupRepositoryFactory.java @@ -76,8 +76,7 @@ public BackupRepository newInstance(SolrResourceLoader loader, String name) { BackupRepository backupRepository = loader.newInstance(repo.className, BackupRepository.class); backupRepository.init(repo.initArgs); - if (backupRepository instanceof DelegatingBackupRepository) { - DelegatingBackupRepository delegatingRepo = (DelegatingBackupRepository) backupRepository; + if (backupRepository instanceof DelegatingBackupRepository delegatingRepo) { String delegateName = (String) repo.initArgs.get(PARAM_DELEGATE_REPOSITORY_NAME); if (delegateName == null) { throw new SolrException( diff --git a/solr/core/src/java/org/apache/solr/filestore/FileStoreAPI.java b/solr/core/src/java/org/apache/solr/filestore/FileStoreAPI.java index 14e8e1e0c34..ae16148a1e6 100644 --- a/solr/core/src/java/org/apache/solr/filestore/FileStoreAPI.java +++ b/solr/core/src/java/org/apache/solr/filestore/FileStoreAPI.java @@ -57,8 +57,7 @@ public int hashCode() { @Override public boolean equals(Object that) { - if (that instanceof MetaData) { - MetaData metaData = (MetaData) that; + if (that instanceof MetaData metaData) { return Objects.equals(sha512, metaData.sha512) && Objects.equals(signatures, metaData.signatures) && Objects.equals(otherAttribs, metaData.otherAttribs); diff --git a/solr/core/src/java/org/apache/solr/handler/AnalysisRequestHandlerBase.java b/solr/core/src/java/org/apache/solr/handler/AnalysisRequestHandlerBase.java index faa79850ab6..ed3bc83ccd2 100644 --- a/solr/core/src/java/org/apache/solr/handler/AnalysisRequestHandlerBase.java +++ b/solr/core/src/java/org/apache/solr/handler/AnalysisRequestHandlerBase.java @@ -305,8 +305,7 @@ public void reflect(Class attClass, String key, Object valu k = ATTRIBUTE_MAPPING.get(k); } - if (value instanceof BytesRef) { - final BytesRef p = (BytesRef) value; + if (value instanceof BytesRef p) { value = p.toString(); } diff --git a/solr/core/src/java/org/apache/solr/handler/MoreLikeThisHandler.java b/solr/core/src/java/org/apache/solr/handler/MoreLikeThisHandler.java index e2a9572c7ab..e3a5d451cf9 100644 --- a/solr/core/src/java/org/apache/solr/handler/MoreLikeThisHandler.java +++ b/solr/core/src/java/org/apache/solr/handler/MoreLikeThisHandler.java @@ -382,8 +382,7 @@ private BooleanQuery getBoostedQuery(Query mltquery) { for (BooleanClause clause : boostedQuery) { Query q = clause.getQuery(); float originalBoost = 1f; - if (q instanceof BoostQuery) { - BoostQuery bq = (BoostQuery) q; + if (q instanceof BoostQuery bq) { q = bq.getQuery(); originalBoost = bq.getBoost(); } @@ -481,8 +480,7 @@ public List getInterestingTerms(BooleanQuery boostedMLTQuery, i } Query q = o.getQuery(); float boost = 1f; - if (q instanceof BoostQuery) { - BoostQuery bq = (BoostQuery) q; + if (q instanceof BoostQuery bq) { q = bq.getQuery(); boost = bq.getBoost(); } diff --git a/solr/core/src/java/org/apache/solr/handler/ReplicationHandler.java b/solr/core/src/java/org/apache/solr/handler/ReplicationHandler.java index 0440f681079..a73325b49c4 100644 --- a/solr/core/src/java/org/apache/solr/handler/ReplicationHandler.java +++ b/solr/core/src/java/org/apache/solr/handler/ReplicationHandler.java @@ -1314,8 +1314,7 @@ public void inform(SolrCore core) { if (replicateOnOptimize) { IndexDeletionPolicyWrapper wrapper = core.getDeletionPolicy(); IndexDeletionPolicy policy = wrapper == null ? null : wrapper.getWrappedDeletionPolicy(); - if (policy instanceof SolrDeletionPolicy) { - SolrDeletionPolicy solrPolicy = (SolrDeletionPolicy) policy; + if (policy instanceof SolrDeletionPolicy solrPolicy) { if (solrPolicy.getMaxOptimizedCommitsToKeep() < 1) { solrPolicy.setMaxOptimizedCommitsToKeep(1); } diff --git a/solr/core/src/java/org/apache/solr/handler/RequestHandlerBase.java b/solr/core/src/java/org/apache/solr/handler/RequestHandlerBase.java index 0fb625d58e6..43559d170cf 100644 --- a/solr/core/src/java/org/apache/solr/handler/RequestHandlerBase.java +++ b/solr/core/src/java/org/apache/solr/handler/RequestHandlerBase.java @@ -285,8 +285,7 @@ public void handleRequest(SolrQueryRequest req, SolrQueryResponse rsp) { public static void processErrorMetricsOnException(Exception e, HandlerMetrics metrics) { boolean isClientError = false; - if (e instanceof SolrException) { - final SolrException se = (SolrException) e; + if (e instanceof SolrException se) { if (se.code() == SolrException.ErrorCode.CONFLICT.code) { return; } else if (se.code() >= 400 && se.code() < 500) { diff --git a/solr/core/src/java/org/apache/solr/handler/SolrConfigHandler.java b/solr/core/src/java/org/apache/solr/handler/SolrConfigHandler.java index 8a8a0da4425..4842534259d 100644 --- a/solr/core/src/java/org/apache/solr/handler/SolrConfigHandler.java +++ b/solr/core/src/java/org/apache/solr/handler/SolrConfigHandler.java @@ -501,8 +501,7 @@ private void handleParams(ArrayList ops, RequestParams params) } SolrResourceLoader loader = req.getCore().getResourceLoader(); - if (loader instanceof ZkSolrResourceLoader) { - ZkSolrResourceLoader zkLoader = (ZkSolrResourceLoader) loader; + if (loader instanceof ZkSolrResourceLoader zkLoader) { if (ops.isEmpty()) { ZkController.touchConfDir(zkLoader); } else { diff --git a/solr/core/src/java/org/apache/solr/handler/StreamHandler.java b/solr/core/src/java/org/apache/solr/handler/StreamHandler.java index 756a7956483..4f80731614d 100644 --- a/solr/core/src/java/org/apache/solr/handler/StreamHandler.java +++ b/solr/core/src/java/org/apache/solr/handler/StreamHandler.java @@ -240,8 +240,7 @@ public void handleRequestBody(SolrQueryRequest req, SolrQueryResponse rsp) throw rsp.add("explanation", tupleStream.toExplanation(this.streamFactory)); } - if (tupleStream instanceof DaemonStream) { - DaemonStream daemonStream = (DaemonStream) tupleStream; + if (tupleStream instanceof DaemonStream daemonStream) { if (daemons.containsKey(daemonStream.getId())) { daemons.remove(daemonStream.getId()).close(); } diff --git a/solr/core/src/java/org/apache/solr/handler/admin/IndexSizeEstimator.java b/solr/core/src/java/org/apache/solr/handler/admin/IndexSizeEstimator.java index 87d4764acba..f5e6bcf8c24 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/IndexSizeEstimator.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/IndexSizeEstimator.java @@ -276,13 +276,11 @@ public Estimate estimate() throws Exception { private void convert(Map result) { for (Map.Entry entry : result.entrySet()) { Object value = entry.getValue(); - if (value instanceof ItemPriorityQueue) { - ItemPriorityQueue queue = (ItemPriorityQueue) value; + if (value instanceof ItemPriorityQueue queue) { Map map = new LinkedHashMap<>(); queue.toMap(map); entry.setValue(map); - } else if (value instanceof MapWriterSummaryStatistics) { - MapWriterSummaryStatistics stats = (MapWriterSummaryStatistics) value; + } else if (value instanceof MapWriterSummaryStatistics stats) { Map map = new LinkedHashMap<>(); stats.toMap(map); entry.setValue(map); @@ -308,8 +306,7 @@ private void estimateSummary(Map details, Map su ((Map) perField) .forEach( (k, val) -> { - if (val instanceof SummaryStatistics) { - SummaryStatistics stats = (SummaryStatistics) val; + if (val instanceof SummaryStatistics stats) { if (k.startsWith("lengths")) { AtomicLong total = (AtomicLong) @@ -596,8 +593,7 @@ private void estimateStoredFields(Map result) throws IOException LeafReader leafReader = context.reader(); EstimatingVisitor visitor = new EstimatingVisitor(stats, topN, maxLength, samplingStep); Bits liveDocs = leafReader.getLiveDocs(); - if (leafReader instanceof CodecReader) { - CodecReader codecReader = (CodecReader) leafReader; + if (leafReader instanceof CodecReader codecReader) { StoredFieldsReader storedFieldsReader = codecReader.getFieldsReader(); // this instance may be faster for a full sequential pass StoredFieldsReader mergeInstance = storedFieldsReader.getMergeInstance(); diff --git a/solr/core/src/java/org/apache/solr/handler/admin/LukeRequestHandler.java b/solr/core/src/java/org/apache/solr/handler/admin/LukeRequestHandler.java index c99c6f9afea..f06ec4369b1 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/LukeRequestHandler.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/LukeRequestHandler.java @@ -547,9 +547,7 @@ private static SimpleOrderedMap getSimilarityInfo(Similarity similarity) private static SimpleOrderedMap getAnalyzerInfo(Analyzer analyzer) { SimpleOrderedMap aninfo = new SimpleOrderedMap<>(); aninfo.add("className", analyzer.getClass().getName()); - if (analyzer instanceof TokenizerChain) { - - TokenizerChain tchain = (TokenizerChain) analyzer; + if (analyzer instanceof TokenizerChain tchain) { CharFilterFactory[] cfiltfacs = tchain.getCharFilterFactories(); if (0 < cfiltfacs.length) { diff --git a/solr/core/src/java/org/apache/solr/handler/admin/SegmentsInfoRequestHandler.java b/solr/core/src/java/org/apache/solr/handler/admin/SegmentsInfoRequestHandler.java index 5acd633d11b..93cdf071a1c 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/SegmentsInfoRequestHandler.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/SegmentsInfoRequestHandler.java @@ -237,8 +237,7 @@ private SimpleOrderedMap getSegmentInfo( for (LeafReaderContext lrc : leafContexts) { LeafReader leafReader = lrc.reader(); leafReader = FilterLeafReader.unwrap(leafReader); - if (leafReader instanceof SegmentReader) { - SegmentReader sr = (SegmentReader) leafReader; + if (leafReader instanceof SegmentReader sr) { if (sr.getSegmentInfo().info.equals(segmentCommitInfo.info)) { seg = sr; break; diff --git a/solr/core/src/java/org/apache/solr/handler/admin/SplitOp.java b/solr/core/src/java/org/apache/solr/handler/admin/SplitOp.java index fd29d31fcd0..e244f3e2543 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/SplitOp.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/SplitOp.java @@ -158,8 +158,7 @@ public void execute(CoreAdminHandler.CallInfo it) throws Exception { } Object routerObj = collection.get(CollectionStateProps.DOC_ROUTER); // for back-compat with Solr 4.4 - if (routerObj instanceof Map) { - Map routerProps = (Map) routerObj; + if (routerObj instanceof Map routerProps) { routeFieldName = (String) routerProps.get("field"); } } @@ -275,8 +274,7 @@ private void handleGetRanges(CoreAdminHandler.CallInfo it, String coreName) thro Object routerObj = collection.get(CollectionStateProps.DOC_ROUTER); // for back-compat with Solr 4.4 - if (routerObj instanceof Map) { - Map routerProps = (Map) routerObj; + if (routerObj instanceof Map routerProps) { routeFieldName = (String) routerProps.get("field"); } if (routeFieldName == null) { diff --git a/solr/core/src/java/org/apache/solr/handler/admin/SystemInfoHandler.java b/solr/core/src/java/org/apache/solr/handler/admin/SystemInfoHandler.java index 6f30e06b340..f3988a6b725 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/SystemInfoHandler.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/SystemInfoHandler.java @@ -336,8 +336,7 @@ public SimpleOrderedMap getSecurityInfo(SolrQueryRequest req) { // Mapped roles for this principal @SuppressWarnings("resource") AuthorizationPlugin auth = cc == null ? null : cc.getAuthorizationPlugin(); - if (auth instanceof RuleBasedAuthorizationPluginBase) { - RuleBasedAuthorizationPluginBase rbap = (RuleBasedAuthorizationPluginBase) auth; + if (auth instanceof RuleBasedAuthorizationPluginBase rbap) { Set roles = rbap.getUserRoles(req.getUserPrincipal()); info.add("roles", roles); if (roles == null) { diff --git a/solr/core/src/java/org/apache/solr/handler/admin/api/GetSchema.java b/solr/core/src/java/org/apache/solr/handler/admin/api/GetSchema.java index 909d0cfe997..7d914533b35 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/api/GetSchema.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/api/GetSchema.java @@ -110,8 +110,7 @@ public SchemaZkVersionResponse getSchemaZkVersion(Integer refreshIfBelowVersion) final SchemaZkVersionResponse response = instantiateJerseyResponse(SchemaZkVersionResponse.class); int zkVersion = -1; - if (solrCore.getLatestSchema() instanceof ManagedIndexSchema) { - ManagedIndexSchema managed = (ManagedIndexSchema) solrCore.getLatestSchema(); + if (solrCore.getLatestSchema() instanceof ManagedIndexSchema managed) { zkVersion = managed.getSchemaZkVersion(); if (refreshIfBelowVersion != -1 && zkVersion < refreshIfBelowVersion) { log.info( diff --git a/solr/core/src/java/org/apache/solr/handler/admin/api/GetSchemaField.java b/solr/core/src/java/org/apache/solr/handler/admin/api/GetSchemaField.java index 3a82d9d6fa5..70fc868bee5 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/api/GetSchemaField.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/api/GetSchemaField.java @@ -193,8 +193,7 @@ private SimpleOrderedMap retrieveFieldInfoOfType( String camelCaseRealName = IndexSchema.nameMapping.get(realName); Map propertyValues = indexSchema.getNamedPropertyValues(realName, params); Object o = propertyValues.get(camelCaseRealName); - if (o instanceof List) { - List list = (List) o; + if (o instanceof List list) { for (Object obj : list) { if (obj instanceof SimpleOrderedMap) { SimpleOrderedMap fieldInfo = (SimpleOrderedMap) obj; @@ -216,8 +215,7 @@ private SimpleOrderedMap retrieveFieldInfoOfType( * the response */ private void insertPackageInfo(Object o) { - if (o instanceof List) { - List l = (List) o; + if (o instanceof List l) { for (Object o1 : l) { if (o1 instanceof NamedList || o1 instanceof List) insertPackageInfo(o1); } @@ -230,8 +228,7 @@ private void insertPackageInfo(Object o) { if (v instanceof NamedList || v instanceof List) insertPackageInfo(v); }); Object v = nl.get("class"); - if (v instanceof String) { - String klas = (String) v; + if (v instanceof String klas) { PluginInfo.ClassName parsedClassName = new PluginInfo.ClassName(klas); if (parsedClassName.pkg != null) { SolrClassLoader solrClassLoader = indexSchema.getSolrClassLoader(); 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 001b6c3338a..0adcdb93b1f 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 @@ -338,9 +338,8 @@ protected Object merge(Object source, Object dest, Set exclude) { } } - if (source instanceof NamedList && dest instanceof NamedList) { + if (source instanceof NamedList sl && dest instanceof NamedList) { NamedList tmp = new NamedList<>(); - NamedList sl = (NamedList) source; @SuppressWarnings("unchecked") NamedList dl = (NamedList) dest; for (int i = 0; i < sl.size(); i++) { diff --git a/solr/core/src/java/org/apache/solr/handler/component/ExpandComponent.java b/solr/core/src/java/org/apache/solr/handler/component/ExpandComponent.java index 45a498bdffa..e998411ed4a 100644 --- a/solr/core/src/java/org/apache/solr/handler/component/ExpandComponent.java +++ b/solr/core/src/java/org/apache/solr/handler/component/ExpandComponent.java @@ -144,9 +144,7 @@ public void process(ResponseBuilder rb) throws IOException { if (filters != null) { int cost = Integer.MAX_VALUE; for (Query q : filters) { - if (q instanceof CollapsingQParserPlugin.CollapsingPostFilter) { - CollapsingQParserPlugin.CollapsingPostFilter cp = - (CollapsingQParserPlugin.CollapsingPostFilter) q; + if (q instanceof CollapsingQParserPlugin.CollapsingPostFilter cp) { // if there are multiple collapse pick the low cost one // if cost are equal then first one is picked if (cp.getCost() < cost) { diff --git a/solr/core/src/java/org/apache/solr/handler/component/QueryComponent.java b/solr/core/src/java/org/apache/solr/handler/component/QueryComponent.java index 2a2363dab3b..0552c6a0c4e 100644 --- a/solr/core/src/java/org/apache/solr/handler/component/QueryComponent.java +++ b/solr/core/src/java/org/apache/solr/handler/component/QueryComponent.java @@ -195,8 +195,7 @@ public void prepare(ResponseBuilder rb) throws IOException { if (rankQueryString != null) { QParser rqparser = QParser.getParser(rankQueryString, req); Query rq = rqparser.getQuery(); - if (rq instanceof RankQuery) { - RankQuery rankQuery = (RankQuery) rq; + if (rq instanceof RankQuery rankQuery) { rb.setRankQuery(rankQuery); MergeStrategy mergeStrategy = rankQuery.getMergeStrategy(); if (mergeStrategy != null) { diff --git a/solr/core/src/java/org/apache/solr/handler/component/QueryElevationComponent.java b/solr/core/src/java/org/apache/solr/handler/component/QueryElevationComponent.java index c7bef72294c..155efd7674a 100644 --- a/solr/core/src/java/org/apache/solr/handler/component/QueryElevationComponent.java +++ b/solr/core/src/java/org/apache/solr/handler/component/QueryElevationComponent.java @@ -1117,10 +1117,9 @@ protected ElevatingQuery(String queryString, boolean subsetMatch) { @Override public boolean equals(Object o) { - if (!(o instanceof ElevatingQuery)) { + if (!(o instanceof ElevatingQuery eq)) { return false; } - ElevatingQuery eq = (ElevatingQuery) o; return queryString.equals(eq.queryString) && subsetMatch == eq.subsetMatch; } diff --git a/solr/core/src/java/org/apache/solr/handler/component/RealTimeGetComponent.java b/solr/core/src/java/org/apache/solr/handler/component/RealTimeGetComponent.java index f1fc77d9ceb..6118b21a086 100644 --- a/solr/core/src/java/org/apache/solr/handler/component/RealTimeGetComponent.java +++ b/solr/core/src/java/org/apache/solr/handler/component/RealTimeGetComponent.java @@ -879,8 +879,7 @@ private static SolrInputDocument toSolrInputDocument(SolrDocument doc, IndexSche if ((!sf.hasDocValues() && !sf.stored()) || schema.isCopyFieldTarget(sf)) continue; } for (Object val : doc.getFieldValues(fname)) { - if (val instanceof IndexableField) { - IndexableField f = (IndexableField) val; + if (val instanceof IndexableField f) { // materialize: if (sf != null) { val = sf.getType().toObject(f); // object or external string? diff --git a/solr/core/src/java/org/apache/solr/handler/component/ShardDoc.java b/solr/core/src/java/org/apache/solr/handler/component/ShardDoc.java index ad204a0904b..0b6414834f2 100644 --- a/solr/core/src/java/org/apache/solr/handler/component/ShardDoc.java +++ b/solr/core/src/java/org/apache/solr/handler/component/ShardDoc.java @@ -61,9 +61,8 @@ public ShardDoc() { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof ShardDoc)) return false; + if (!(o instanceof ShardDoc shardDoc)) return false; - ShardDoc shardDoc = (ShardDoc) o; return Objects.equals(id, shardDoc.id); } diff --git a/solr/core/src/java/org/apache/solr/handler/component/StatsField.java b/solr/core/src/java/org/apache/solr/handler/component/StatsField.java index e74e00f015b..6dbeea65dd7 100644 --- a/solr/core/src/java/org/apache/solr/handler/component/StatsField.java +++ b/solr/core/src/java/org/apache/solr/handler/component/StatsField.java @@ -405,8 +405,7 @@ public DocSet computeBaseDocSet() throws IOException { // tagMap has entries of List>, but subject to change in the future if (!(olst instanceof Collection)) continue; for (Object o : (Collection) olst) { - if (!(o instanceof QParser)) continue; - QParser qp = (QParser) o; + if (!(o instanceof QParser qp)) continue; try { excludeSet.put(qp.getQuery(), Boolean.TRUE); } catch (SyntaxError e) { diff --git a/solr/core/src/java/org/apache/solr/handler/designer/DefaultSchemaSuggester.java b/solr/core/src/java/org/apache/solr/handler/designer/DefaultSchemaSuggester.java index dd98eb728e2..d3dc4acaf5b 100644 --- a/solr/core/src/java/org/apache/solr/handler/designer/DefaultSchemaSuggester.java +++ b/solr/core/src/java/org/apache/solr/handler/designer/DefaultSchemaSuggester.java @@ -275,11 +275,10 @@ protected boolean isText(List values) { int maxLength = -1; int maxTerms = -1; for (Object next : values) { - if (!(next instanceof String)) { + if (!(next instanceof String cs)) { return false; } - String cs = (String) next; int len = cs.length(); if (len > maxLength) { maxLength = len; diff --git a/solr/core/src/java/org/apache/solr/handler/designer/SchemaDesignerConfigSetHelper.java b/solr/core/src/java/org/apache/solr/handler/designer/SchemaDesignerConfigSetHelper.java index 9b5e7a82bf8..0b14b0d4cf4 100644 --- a/solr/core/src/java/org/apache/solr/handler/designer/SchemaDesignerConfigSetHelper.java +++ b/solr/core/src/java/org/apache/solr/handler/designer/SchemaDesignerConfigSetHelper.java @@ -324,8 +324,7 @@ protected boolean updateFieldType( // nice, the json for this field looks like // "synonymQueryStyle": // "org.apache.solr.parser.SolrQueryParserBase$SynonymQueryStyle:AS_SAME_TERM" - if (typeAttrs.get("synonymQueryStyle") instanceof String) { - String synonymQueryStyle = (String) typeAttrs.get("synonymQueryStyle"); + if (typeAttrs.get("synonymQueryStyle") instanceof String synonymQueryStyle) { if (synonymQueryStyle.lastIndexOf(':') != -1) { typeAttrs.put( "synonymQueryStyle", diff --git a/solr/core/src/java/org/apache/solr/handler/designer/SchemaDesignerSettings.java b/solr/core/src/java/org/apache/solr/handler/designer/SchemaDesignerSettings.java index 4f16464fedd..0216d433ee5 100644 --- a/solr/core/src/java/org/apache/solr/handler/designer/SchemaDesignerSettings.java +++ b/solr/core/src/java/org/apache/solr/handler/designer/SchemaDesignerSettings.java @@ -144,8 +144,7 @@ public void setFieldGuessingEnabled(boolean enabled) { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof SchemaDesignerSettings)) return false; - SchemaDesignerSettings that = (SchemaDesignerSettings) o; + if (!(o instanceof SchemaDesignerSettings that)) return false; return isDisabled == that.isDisabled && dynamicFieldsEnabled == that.dynamicFieldsEnabled && nestedDocsEnabled == that.nestedDocsEnabled diff --git a/solr/core/src/java/org/apache/solr/handler/loader/JavabinLoader.java b/solr/core/src/java/org/apache/solr/handler/loader/JavabinLoader.java index e65b0e2e1a9..1269021aa2f 100644 --- a/solr/core/src/java/org/apache/solr/handler/loader/JavabinLoader.java +++ b/solr/core/src/java/org/apache/solr/handler/loader/JavabinLoader.java @@ -164,9 +164,8 @@ public List readIterator(DataInputInputStream fis) throws IOException { params = ((NamedList) o).toSolrParams(); } else { try { - if (o instanceof byte[]) { + if (o instanceof byte[] buf) { if (params != null) req.setParams(params); - byte[] buf = (byte[]) o; contentStreamLoader.load( req, rsp, new ContentStreamBase.ByteArrayStream(buf, null), processor); } else { diff --git a/solr/core/src/java/org/apache/solr/handler/loader/JsonLoader.java b/solr/core/src/java/org/apache/solr/handler/loader/JsonLoader.java index 48e095a092c..ff07a8fb5a9 100644 --- a/solr/core/src/java/org/apache/solr/handler/loader/JsonLoader.java +++ b/solr/core/src/java/org/apache/solr/handler/loader/JsonLoader.java @@ -92,8 +92,7 @@ public static SolrInputDocument buildDoc(Map m) { SolrInputDocument result = new SolrInputDocument(); for (Map.Entry e : m.entrySet()) { if (mapEntryIsChildDoc(e.getValue())) { // parse child documents - if (e.getValue() instanceof List) { - List value = (List) e.getValue(); + if (e.getValue() instanceof List value) { for (Object o : value) { if (o instanceof Map) { // retain the value as a list, even if the list contains a single value. @@ -114,8 +113,7 @@ public static SolrInputDocument buildDoc(Map m) { } private static boolean mapEntryIsChildDoc(Object val) { - if (val instanceof List) { - List listVal = (List) val; + if (val instanceof List listVal) { if (listVal.size() == 0) return false; return listVal.get(0) instanceof Map; } @@ -297,9 +295,8 @@ public void handle(Map record, String path) { private Map getDocMap( Map record, JSONParser parser, String srcField, boolean mapUniqueKeyOnly) { Map result = mapUniqueKeyOnly ? record : new LinkedHashMap<>(record); - if (srcField != null && parser instanceof RecordingJSONParser) { + if (srcField != null && parser instanceof RecordingJSONParser rjp) { // if srcFIeld specified extract it out first - RecordingJSONParser rjp = (RecordingJSONParser) parser; result.put(srcField, rjp.getBuf()); rjp.resetBuf(); } diff --git a/solr/core/src/java/org/apache/solr/handler/tagger/TaggerRequestHandler.java b/solr/core/src/java/org/apache/solr/handler/tagger/TaggerRequestHandler.java index c85aeafedcb..2c4c07d0a13 100644 --- a/solr/core/src/java/org/apache/solr/handler/tagger/TaggerRequestHandler.java +++ b/solr/core/src/java/org/apache/solr/handler/tagger/TaggerRequestHandler.java @@ -351,8 +351,7 @@ private Bits computeDocCorpus(SolrQueryRequest req) throws SyntaxError, IOExcept private boolean fieldHasIndexedStopFilter(String field, SolrQueryRequest req) { FieldType fieldType = req.getSchema().getFieldType(field); Analyzer analyzer = fieldType.getIndexAnalyzer(); // index analyzer - if (analyzer instanceof TokenizerChain) { - TokenizerChain tokenizerChain = (TokenizerChain) analyzer; + if (analyzer instanceof TokenizerChain tokenizerChain) { TokenFilterFactory[] tokenFilterFactories = tokenizerChain.getTokenFilterFactories(); for (TokenFilterFactory tokenFilterFactory : tokenFilterFactories) { if (tokenFilterFactory instanceof StopFilterFactory) return true; diff --git a/solr/core/src/java/org/apache/solr/jersey/CatchAllExceptionMapper.java b/solr/core/src/java/org/apache/solr/jersey/CatchAllExceptionMapper.java index 3db1c921398..1110880529c 100644 --- a/solr/core/src/java/org/apache/solr/jersey/CatchAllExceptionMapper.java +++ b/solr/core/src/java/org/apache/solr/jersey/CatchAllExceptionMapper.java @@ -65,8 +65,7 @@ public Response toResponse(Exception exception) { (SolrQueryResponse) containerRequestContext.getProperty(SOLR_QUERY_RESPONSE); final SolrQueryRequest solrQueryRequest = (SolrQueryRequest) containerRequestContext.getProperty(SOLR_QUERY_REQUEST); - if (exception instanceof WebApplicationException) { - final WebApplicationException wae = (WebApplicationException) exception; + if (exception instanceof WebApplicationException wae) { final SolrException solrException = new SolrException(getErrorCode(wae.getResponse().getStatus()), wae.getMessage()); solrQueryResponse.setException(solrException); diff --git a/solr/core/src/java/org/apache/solr/legacy/BBoxStrategy.java b/solr/core/src/java/org/apache/solr/legacy/BBoxStrategy.java index d572bbd7c75..4ce80840064 100644 --- a/solr/core/src/java/org/apache/solr/legacy/BBoxStrategy.java +++ b/solr/core/src/java/org/apache/solr/legacy/BBoxStrategy.java @@ -177,13 +177,12 @@ public BBoxStrategy(SpatialContext ctx, String fieldNamePrefix, FieldType fieldT numQuads++; } if (fieldType.indexOptions() != IndexOptions.NONE - && fieldType instanceof LegacyFieldType - && ((LegacyFieldType) fieldType).numericType() != null) { + && fieldType instanceof LegacyFieldType legacyType + && legacyType.numericType() != null) { if (hasPointVals) { throw new IllegalArgumentException( "pointValues and LegacyNumericType are mutually exclusive"); } - final LegacyFieldType legacyType = (LegacyFieldType) fieldType; if (legacyType.numericType() != LegacyNumericType.DOUBLE) { throw new IllegalArgumentException( getClass() + " does not support " + legacyType.numericType()); @@ -302,10 +301,9 @@ public DoubleValuesSource makeOverlapRatioValueSource( @Override public Query makeQuery(SpatialArgs args) { Shape shape = args.getShape(); - if (!(shape instanceof Rectangle)) + if (!(shape instanceof Rectangle bbox)) throw new UnsupportedOperationException("Can only query by Rectangle, not " + shape); - Rectangle bbox = (Rectangle) shape; Query spatial; // Useful for understanding Relations: diff --git a/solr/core/src/java/org/apache/solr/legacy/BBoxValueSource.java b/solr/core/src/java/org/apache/solr/legacy/BBoxValueSource.java index d04f8046004..b7b794917e4 100644 --- a/solr/core/src/java/org/apache/solr/legacy/BBoxValueSource.java +++ b/solr/core/src/java/org/apache/solr/legacy/BBoxValueSource.java @@ -88,9 +88,7 @@ public boolean isCacheable(LeafReaderContext ctx) { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof BBoxValueSource)) return false; - - BBoxValueSource that = (BBoxValueSource) o; + if (!(o instanceof BBoxValueSource that)) return false; return strategy.equals(that.strategy); } diff --git a/solr/core/src/java/org/apache/solr/legacy/LegacyFieldType.java b/solr/core/src/java/org/apache/solr/legacy/LegacyFieldType.java index 98199d62b6a..c038d804b7a 100644 --- a/solr/core/src/java/org/apache/solr/legacy/LegacyFieldType.java +++ b/solr/core/src/java/org/apache/solr/legacy/LegacyFieldType.java @@ -114,8 +114,7 @@ public boolean equals(Object obj) { if (!super.equals(obj)) { return false; } - if (!(obj instanceof LegacyFieldType)) return false; - LegacyFieldType other = (LegacyFieldType) obj; + if (!(obj instanceof LegacyFieldType other)) return false; if (numericPrecisionStep != other.numericPrecisionStep) return false; return numericType == other.numericType; } diff --git a/solr/core/src/java/org/apache/solr/legacy/LegacyNumericRangeQuery.java b/solr/core/src/java/org/apache/solr/legacy/LegacyNumericRangeQuery.java index 617dcfa57b4..0fbc78e3142 100644 --- a/solr/core/src/java/org/apache/solr/legacy/LegacyNumericRangeQuery.java +++ b/solr/core/src/java/org/apache/solr/legacy/LegacyNumericRangeQuery.java @@ -422,8 +422,7 @@ public String toString(final String field) { public final boolean equals(final Object o) { if (o == this) return true; if (!super.equals(o)) return false; - if (o instanceof LegacyNumericRangeQuery) { - final LegacyNumericRangeQuery q = (LegacyNumericRangeQuery) o; + if (o instanceof LegacyNumericRangeQuery q) { return Objects.equals(q.min, min) && Objects.equals(q.max, max) && minInclusive == q.minInclusive diff --git a/solr/core/src/java/org/apache/solr/legacy/LegacyNumericTokenStream.java b/solr/core/src/java/org/apache/solr/legacy/LegacyNumericTokenStream.java index 5f72628402c..9ac670fce22 100644 --- a/solr/core/src/java/org/apache/solr/legacy/LegacyNumericTokenStream.java +++ b/solr/core/src/java/org/apache/solr/legacy/LegacyNumericTokenStream.java @@ -254,8 +254,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { if (this == obj) return true; - if (!(obj instanceof LegacyNumericTermAttributeImpl)) return false; - LegacyNumericTermAttributeImpl other = (LegacyNumericTermAttributeImpl) obj; + if (!(obj instanceof LegacyNumericTermAttributeImpl other)) return false; if (precisionStep != other.precisionStep) return false; if (shift != other.shift) return false; if (value != other.value) return false; diff --git a/solr/core/src/java/org/apache/solr/metrics/AggregateMetric.java b/solr/core/src/java/org/apache/solr/metrics/AggregateMetric.java index 97be390c6b0..638f2ebc644 100644 --- a/solr/core/src/java/org/apache/solr/metrics/AggregateMetric.java +++ b/solr/core/src/java/org/apache/solr/metrics/AggregateMetric.java @@ -90,10 +90,9 @@ public double getMax() { } Double res = null; for (Update u : values.values()) { - if (!(u.value instanceof Number)) { + if (!(u.value instanceof Number n)) { continue; } - Number n = (Number) u.value; if (res == null) { res = n.doubleValue(); continue; @@ -114,10 +113,9 @@ public double getMin() { } Double res = null; for (Update u : values.values()) { - if (!(u.value instanceof Number)) { + if (!(u.value instanceof Number n)) { continue; } - Number n = (Number) u.value; if (res == null) { res = n.doubleValue(); continue; @@ -138,10 +136,9 @@ public double getMean() { } double total = 0; for (Update u : values.values()) { - if (!(u.value instanceof Number)) { + if (!(u.value instanceof Number n)) { continue; } - Number n = (Number) u.value; total += n.doubleValue(); } return total / values.size(); @@ -156,11 +153,10 @@ public double getStdDev() { double sum = 0; int count = 0; for (Update u : values.values()) { - if (!(u.value instanceof Number)) { + if (!(u.value instanceof Number n)) { continue; } count++; - Number n = (Number) u.value; final double diff = n.doubleValue() - mean; sum += diff * diff; } @@ -177,10 +173,9 @@ public double getSum() { } double res = 0; for (Update u : values.values()) { - if (!(u.value instanceof Number)) { + if (!(u.value instanceof Number n)) { continue; } - Number n = (Number) u.value; res += n.doubleValue(); } return res; diff --git a/solr/core/src/java/org/apache/solr/metrics/SolrMetricInfo.java b/solr/core/src/java/org/apache/solr/metrics/SolrMetricInfo.java index 2c8b9aa95cd..a016fab7827 100644 --- a/solr/core/src/java/org/apache/solr/metrics/SolrMetricInfo.java +++ b/solr/core/src/java/org/apache/solr/metrics/SolrMetricInfo.java @@ -94,9 +94,8 @@ public String toString() { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof SolrMetricInfo)) return false; + if (!(o instanceof SolrMetricInfo that)) return false; - SolrMetricInfo that = (SolrMetricInfo) o; return Objects.equals(name, that.name) && Objects.equals(scope, that.scope) && category == that.category; diff --git a/solr/core/src/java/org/apache/solr/metrics/SolrMetricManager.java b/solr/core/src/java/org/apache/solr/metrics/SolrMetricManager.java index 06bea336dd1..52c468445cb 100644 --- a/solr/core/src/java/org/apache/solr/metrics/SolrMetricManager.java +++ b/solr/core/src/java/org/apache/solr/metrics/SolrMetricManager.java @@ -835,8 +835,7 @@ public int unregisterGauges(String registryName, String tagSegment) { AtomicInteger removed = new AtomicInteger(); registry.removeMatching( (name, metric) -> { - if (metric instanceof GaugeWrapper) { - GaugeWrapper wrapper = (GaugeWrapper) metric; + if (metric instanceof GaugeWrapper wrapper) { boolean toRemove = wrapper.getTag().contains(tagSegment); if (toRemove) { removed.incrementAndGet(); diff --git a/solr/core/src/java/org/apache/solr/metrics/prometheus/SolrPrometheusFormatter.java b/solr/core/src/java/org/apache/solr/metrics/prometheus/SolrPrometheusFormatter.java index 8c1ba8652ab..5a8a2de4f04 100644 --- a/solr/core/src/java/org/apache/solr/metrics/prometheus/SolrPrometheusFormatter.java +++ b/solr/core/src/java/org/apache/solr/metrics/prometheus/SolrPrometheusFormatter.java @@ -140,8 +140,7 @@ public void exportGauge( GaugeSnapshot.GaugeDataPointSnapshot dataPoint = createGaugeDatapoint(((Number) dropwizardMetric).doubleValue(), labels); collectGaugeDatapoint(metricName, dataPoint); - } else if (dropwizardMetric instanceof HashMap) { - HashMap itemsMap = (HashMap) dropwizardMetric; + } else if (dropwizardMetric instanceof HashMap itemsMap) { for (Object item : itemsMap.keySet()) { if (itemsMap.get(item) instanceof Number) { GaugeSnapshot.GaugeDataPointSnapshot dataPoint = diff --git a/solr/core/src/java/org/apache/solr/metrics/reporters/jmx/JmxMetricsReporter.java b/solr/core/src/java/org/apache/solr/metrics/reporters/jmx/JmxMetricsReporter.java index 34059b562a6..bd9eb1b2b21 100644 --- a/solr/core/src/java/org/apache/solr/metrics/reporters/jmx/JmxMetricsReporter.java +++ b/solr/core/src/java/org/apache/solr/metrics/reporters/jmx/JmxMetricsReporter.java @@ -580,8 +580,7 @@ public void onGaugeAdded(String name, Gauge gauge) { if (filter.matches(name, gauge)) { final ObjectName objectName = createName("gauges", name); if (gauge instanceof SolrMetricManager.GaugeWrapper - && ((SolrMetricManager.GaugeWrapper) gauge).getGauge() instanceof MetricsMap) { - MetricsMap mm = (MetricsMap) ((SolrMetricManager.GaugeWrapper) gauge).getGauge(); + && ((SolrMetricManager.GaugeWrapper) gauge).getGauge() instanceof MetricsMap mm) { mm.setAttribute(new Attribute(INSTANCE_TAG, tag)); // don't wrap it in a JmxGauge, it already supports all necessary JMX attributes registerMBean(mm, objectName); diff --git a/solr/core/src/java/org/apache/solr/parser/SolrQueryParserBase.java b/solr/core/src/java/org/apache/solr/parser/SolrQueryParserBase.java index bdea4869e12..4160fd7a648 100644 --- a/solr/core/src/java/org/apache/solr/parser/SolrQueryParserBase.java +++ b/solr/core/src/java/org/apache/solr/parser/SolrQueryParserBase.java @@ -549,8 +549,7 @@ protected Query getFieldQuery(String field, String queryText, int slop) throws S // only set slop of the phrase query was a result of this parser // and not a sub-parser. if (subQParser == null) { - if (query instanceof PhraseQuery) { - PhraseQuery pq = (PhraseQuery) query; + if (query instanceof PhraseQuery pq) { Term[] terms = pq.getTerms(); int[] positions = pq.getPositions(); PhraseQuery.Builder builder = new PhraseQuery.Builder(); @@ -559,8 +558,7 @@ protected Query getFieldQuery(String field, String queryText, int slop) throws S } builder.setSlop(slop); query = builder.build(); - } else if (query instanceof MultiPhraseQuery) { - MultiPhraseQuery mpq = (MultiPhraseQuery) query; + } else if (query instanceof MultiPhraseQuery mpq) { if (slop != mpq.getSlop()) { query = new MultiPhraseQuery.Builder(mpq).setSlop(slop).build(); @@ -1011,9 +1009,8 @@ protected ReversedWildcardFilterFactory getReversedWildcardFilterFactory(FieldTy } Analyzer a = fieldType.getIndexAnalyzer(); - if (a instanceof TokenizerChain) { + if (a instanceof TokenizerChain tc) { // examine the indexing analysis chain if it supports leading wildcards - TokenizerChain tc = (TokenizerChain) a; TokenFilterFactory[] factories = tc.getTokenFilterFactories(); for (TokenFilterFactory factory : factories) { if (factory instanceof ReversedWildcardFilterFactory) { @@ -1053,8 +1050,7 @@ protected String analyzeIfMultitermTermText(String field, String part, FieldType // Create a "normal" query from a RawQuery (or just return the current query if it's not raw) Query rawToNormal(Query q) { Query normal = q; - if (q instanceof RawQuery) { - RawQuery rawq = (RawQuery) q; + if (q instanceof RawQuery rawq) { if (rawq.sfield.getType().isTokenized()) { normal = rawq.sfield.getType().getFieldQuery(parser, rawq.sfield, rawq.getJoinedExternalVal()); diff --git a/solr/core/src/java/org/apache/solr/pkg/PackageAPI.java b/solr/core/src/java/org/apache/solr/pkg/PackageAPI.java index 24339feefe8..24c9800f3e8 100644 --- a/solr/core/src/java/org/apache/solr/pkg/PackageAPI.java +++ b/solr/core/src/java/org/apache/solr/pkg/PackageAPI.java @@ -198,8 +198,7 @@ public PkgVersion(PackagePayload.AddVersion addVersion) { @Override public boolean equals(Object obj) { - if (obj instanceof PkgVersion) { - PkgVersion that = (PkgVersion) obj; + if (obj instanceof PkgVersion that) { return Objects.equals(this.version, that.version) && Objects.equals(this.files, that.files); } return false; diff --git a/solr/core/src/java/org/apache/solr/pkg/PackagePluginHolder.java b/solr/core/src/java/org/apache/solr/pkg/PackagePluginHolder.java index 1f1d2459818..b0731d05095 100644 --- a/solr/core/src/java/org/apache/solr/pkg/PackagePluginHolder.java +++ b/solr/core/src/java/org/apache/solr/pkg/PackagePluginHolder.java @@ -146,8 +146,7 @@ protected Object initNewInstance(SolrPackageLoader.SolrPackage.Version newest, S handleAwareCallbacks(newest.getLoader(), instance, core); T old = inst; inst = (T) instance; - if (old instanceof AutoCloseable) { - AutoCloseable closeable = (AutoCloseable) old; + if (old instanceof AutoCloseable closeable) { try { closeable.close(); } catch (Exception e) { @@ -158,8 +157,7 @@ protected Object initNewInstance(SolrPackageLoader.SolrPackage.Version newest, S } private void handleAwareCallbacks(SolrResourceLoader loader, Object instance, SolrCore core) { - if (instance instanceof SolrCoreAware) { - SolrCoreAware coreAware = (SolrCoreAware) instance; + if (instance instanceof SolrCoreAware coreAware) { if (!core.getResourceLoader().addToCoreAware(coreAware)) { coreAware.inform(core); } diff --git a/solr/core/src/java/org/apache/solr/query/FilterQuery.java b/solr/core/src/java/org/apache/solr/query/FilterQuery.java index 9039bc1f083..8af5a5a51ee 100644 --- a/solr/core/src/java/org/apache/solr/query/FilterQuery.java +++ b/solr/core/src/java/org/apache/solr/query/FilterQuery.java @@ -85,8 +85,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { - if (!(obj instanceof FilterQuery)) return false; - FilterQuery fq = (FilterQuery) obj; + if (!(obj instanceof FilterQuery fq)) return false; return this.q.equals(fq.q); } @@ -119,13 +118,12 @@ public Weight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float bo throws IOException { // SolrRequestInfo reqInfo = SolrRequestInfo.getRequestInfo(); - if (!(searcher instanceof SolrIndexSearcher)) { + if (!(searcher instanceof SolrIndexSearcher solrSearcher)) { // delete-by-query won't have SolrIndexSearcher // note: CSQ has some optimizations so we wrap it even though unnecessary given 0 boost return new ConstantScoreQuery(q).createWeight(searcher, scoreMode, 0f); } - SolrIndexSearcher solrSearcher = (SolrIndexSearcher) searcher; DocSet docs = solrSearcher.getDocSet(q); // reqInfo.addCloseHook(docs); // needed for off-heap refcounting diff --git a/solr/core/src/java/org/apache/solr/query/SolrRangeQuery.java b/solr/core/src/java/org/apache/solr/query/SolrRangeQuery.java index 9aa323ea6ad..c9c6af65ce2 100644 --- a/solr/core/src/java/org/apache/solr/query/SolrRangeQuery.java +++ b/solr/core/src/java/org/apache/solr/query/SolrRangeQuery.java @@ -115,10 +115,9 @@ public boolean equals(Object obj) { if (this == obj) { return true; } - if (!(obj instanceof SolrRangeQuery)) { + if (!(obj instanceof SolrRangeQuery other)) { return false; } - SolrRangeQuery other = (SolrRangeQuery) obj; return (this.flags == other.flags) && (this.field.equals(other.field)) diff --git a/solr/core/src/java/org/apache/solr/request/SimpleFacets.java b/solr/core/src/java/org/apache/solr/request/SimpleFacets.java index 276626123f5..bc8c5e73080 100644 --- a/solr/core/src/java/org/apache/solr/request/SimpleFacets.java +++ b/solr/core/src/java/org/apache/solr/request/SimpleFacets.java @@ -234,8 +234,7 @@ protected DocSet computeDocSet(DocSet baseDocSet, List excludeTagList) // tagMap has entries of List>, but subject to change in the future if (!(olst instanceof Collection)) continue; for (Object o : (Collection) olst) { - if (!(o instanceof QParser)) continue; - QParser qp = (QParser) o; + if (!(o instanceof QParser qp)) continue; excludeSet.put(qp.getQuery(), Boolean.TRUE); } } @@ -1292,8 +1291,7 @@ public int hashCode() { @Override public boolean equals(Object o) { - if (!(o instanceof CountPair)) return false; - CountPair that = (CountPair) o; + if (!(o instanceof CountPair that)) return false; return (this.key.equals(that.key) && this.val.equals(that.val)); } diff --git a/solr/core/src/java/org/apache/solr/request/json/JsonQueryConverter.java b/solr/core/src/java/org/apache/solr/request/json/JsonQueryConverter.java index 7c0baedd9d7..e612f99221a 100644 --- a/solr/core/src/java/org/apache/solr/request/json/JsonQueryConverter.java +++ b/solr/core/src/java/org/apache/solr/request/json/JsonQueryConverter.java @@ -145,14 +145,13 @@ private void buildLocalParams( } else { for (Map.Entry entry : map.entrySet()) { String key = entry.getKey(); - if (entry.getValue() instanceof List) { + if (entry.getValue() instanceof List l) { if (key.equals("query")) { throw new SolrException( SolrException.ErrorCode.BAD_REQUEST, "Error when parsing json query, value of query field should not be a list, found : " + entry.getValue()); } - List l = (List) entry.getValue(); for (Object subVal : l) { builder.append(key).append("="); buildLocalParams(builder, subVal, true, additionalParams); diff --git a/solr/core/src/java/org/apache/solr/request/json/RequestUtil.java b/solr/core/src/java/org/apache/solr/request/json/RequestUtil.java index e6367612951..55f3681e13f 100644 --- a/solr/core/src/java/org/apache/solr/request/json/RequestUtil.java +++ b/solr/core/src/java/org/apache/solr/request/json/RequestUtil.java @@ -363,8 +363,7 @@ private static void getParamsFromJSON(Map params, String json) if (val == null) { params.remove(key); - } else if (val instanceof List) { - List lst = (List) val; + } else if (val instanceof List lst) { String[] vals = new String[lst.size()]; for (int i = 0; i < vals.length; i++) { vals[i] = lst.get(i).toString(); diff --git a/solr/core/src/java/org/apache/solr/response/BinaryResponseWriter.java b/solr/core/src/java/org/apache/solr/response/BinaryResponseWriter.java index 7b72c7e78f6..317412802d1 100644 --- a/solr/core/src/java/org/apache/solr/response/BinaryResponseWriter.java +++ b/solr/core/src/java/org/apache/solr/response/BinaryResponseWriter.java @@ -83,9 +83,8 @@ public Resolver(SolrQueryRequest req, ReturnFields returnFields) { @Override public Object resolve(Object o, JavaBinCodec codec) throws IOException { - if (o instanceof ResultContext) { + if (o instanceof ResultContext res) { ReturnFields orig = returnFields; - ResultContext res = (ResultContext) o; if (res.getReturnFields() != null) { returnFields = res.getReturnFields(); } @@ -111,10 +110,9 @@ public Object resolve(Object o, JavaBinCodec codec) throws IOException { writeResults(ctx, codec); return null; // null means we completely handled it } - if (o instanceof IndexableField) { + if (o instanceof IndexableField f) { if (schema == null) schema = solrQueryRequest.getSchema(); - IndexableField f = (IndexableField) o; SchemaField sf = schema.getFieldOrNull(f.name()); try { o = DocsStreamer.getValue(sf, f); @@ -262,8 +260,7 @@ public Entry next() { @Override public Object getFirstValue(String name) { Object v = _fields.get(name); - if (v == null || !(v instanceof Collection)) return convertCharSeq(v); - Collection c = (Collection) v; + if (v == null || !(v instanceof Collection c)) return convertCharSeq(v); if (c.size() > 0) { return convertCharSeq(c.iterator().next()); } diff --git a/solr/core/src/java/org/apache/solr/response/CSVResponseWriter.java b/solr/core/src/java/org/apache/solr/response/CSVResponseWriter.java index 05df434bf37..8cb30080fd7 100644 --- a/solr/core/src/java/org/apache/solr/response/CSVResponseWriter.java +++ b/solr/core/src/java/org/apache/solr/response/CSVResponseWriter.java @@ -419,8 +419,7 @@ public void writeSolrDocument(String name, SolrDocument doc, ReturnFields return } else { // normalize to first value - if (val instanceof Collection) { - Collection values = (Collection) val; + if (val instanceof Collection values) { val = values.iterator().next(); } // if field is polyfield, use the multi-valued printer to apply appropriate escaping diff --git a/solr/core/src/java/org/apache/solr/response/GraphMLResponseWriter.java b/solr/core/src/java/org/apache/solr/response/GraphMLResponseWriter.java index 6a49f92fdc3..11a04d10240 100644 --- a/solr/core/src/java/org/apache/solr/response/GraphMLResponseWriter.java +++ b/solr/core/src/java/org/apache/solr/response/GraphMLResponseWriter.java @@ -46,8 +46,7 @@ public void write(Writer writer, SolrQueryRequest req, SolrQueryResponse res) th TupleStream stream = (TupleStream) req.getContext().get("stream"); - if (stream instanceof GraphHandler.DummyErrorStream) { - GraphHandler.DummyErrorStream d = (GraphHandler.DummyErrorStream) stream; + if (stream instanceof GraphHandler.DummyErrorStream d) { Exception e = d.getException(); e.printStackTrace(new PrintWriter(writer)); return; diff --git a/solr/core/src/java/org/apache/solr/response/QueryResponseWriterUtil.java b/solr/core/src/java/org/apache/solr/response/QueryResponseWriterUtil.java index 44455a8cf36..1ea0642738d 100644 --- a/solr/core/src/java/org/apache/solr/response/QueryResponseWriterUtil.java +++ b/solr/core/src/java/org/apache/solr/response/QueryResponseWriterUtil.java @@ -49,13 +49,11 @@ public static void writeQueryResponse( String contentType) throws IOException { - if (responseWriter instanceof JacksonJsonWriter) { - JacksonJsonWriter binWriter = (JacksonJsonWriter) responseWriter; + if (responseWriter instanceof JacksonJsonWriter binWriter) { BufferedOutputStream bos = new BufferedOutputStream(new NonFlushingStream(outputStream)); binWriter.write(bos, solrRequest, solrResponse); bos.flush(); - } else if (responseWriter instanceof BinaryQueryResponseWriter) { - BinaryQueryResponseWriter binWriter = (BinaryQueryResponseWriter) responseWriter; + } else if (responseWriter instanceof BinaryQueryResponseWriter binWriter) { binWriter.write(outputStream, solrRequest, solrResponse); } else { OutputStream out = new NonFlushingStream(outputStream); diff --git a/solr/core/src/java/org/apache/solr/response/RawResponseWriter.java b/solr/core/src/java/org/apache/solr/response/RawResponseWriter.java index 34d7e112ed2..d20128ae4e0 100644 --- a/solr/core/src/java/org/apache/solr/response/RawResponseWriter.java +++ b/solr/core/src/java/org/apache/solr/response/RawResponseWriter.java @@ -98,9 +98,8 @@ public String getContentType(SolrQueryRequest request, SolrQueryResponse respons public void write(Writer writer, SolrQueryRequest request, SolrQueryResponse response) throws IOException { Object obj = response.getValues().get(CONTENT); - if (obj != null && (obj instanceof ContentStream)) { + if (obj != null && (obj instanceof ContentStream content)) { // copy the contents to the writer... - ContentStream content = (ContentStream) obj; try (Reader reader = content.getReader()) { reader.transferTo(writer); } @@ -113,14 +112,12 @@ public void write(Writer writer, SolrQueryRequest request, SolrQueryResponse res public void write(OutputStream out, SolrQueryRequest request, SolrQueryResponse response) throws IOException { Object obj = response.getValues().get(CONTENT); - if (obj != null && (obj instanceof ContentStream)) { + if (obj != null && (obj instanceof ContentStream content)) { // copy the contents to the writer... - ContentStream content = (ContentStream) obj; try (InputStream in = content.getStream()) { in.transferTo(out); } - } else if (obj != null && (obj instanceof SolrCore.RawWriter)) { - final var rawWriter = (SolrCore.RawWriter) obj; + } else if (obj != null && (obj instanceof SolrCore.RawWriter rawWriter)) { rawWriter.write(out); if (rawWriter instanceof Closeable) ((Closeable) rawWriter).close(); } else { diff --git a/solr/core/src/java/org/apache/solr/response/TextResponseWriter.java b/solr/core/src/java/org/apache/solr/response/TextResponseWriter.java index 734dd2bea1b..a7017f5d4fb 100644 --- a/solr/core/src/java/org/apache/solr/response/TextResponseWriter.java +++ b/solr/core/src/java/org/apache/solr/response/TextResponseWriter.java @@ -176,8 +176,7 @@ public final void writeVal(String name, Object val, boolean raw) throws IOExcept return; } - if (val instanceof IndexableField) { - IndexableField f = (IndexableField) val; + if (val instanceof IndexableField f) { SchemaField sf = schema.getFieldOrNull(f.name()); if (sf != null) { sf.getType().write(raw ? rawShim : this, name, f); @@ -206,8 +205,7 @@ public final void writeVal(String name, Object val, boolean raw) throws IOExcept // restricts the fields to write...? } else if (val instanceof SolrDocumentList) { writeSolrDocumentList(name, (SolrDocumentList) val, returnFields); - } else if (val instanceof BytesRef) { - BytesRef arr = (BytesRef) val; + } else if (val instanceof BytesRef arr) { writeByteArr(name, arr.bytes, arr.offset, arr.length); } else { TextWriter.super.writeVal(name, val, raw); diff --git a/solr/core/src/java/org/apache/solr/response/transform/BaseEditorialTransformer.java b/solr/core/src/java/org/apache/solr/response/transform/BaseEditorialTransformer.java index 8382f7c0c59..3ff7c639f5d 100644 --- a/solr/core/src/java/org/apache/solr/response/transform/BaseEditorialTransformer.java +++ b/solr/core/src/java/org/apache/solr/response/transform/BaseEditorialTransformer.java @@ -59,8 +59,7 @@ public void transform(SolrDocument doc, int docid) { protected BytesRef getKey(SolrDocument doc) { Object obj = doc.get(idFieldName); - if (obj instanceof IndexableField) { - IndexableField f = (IndexableField) obj; + if (obj instanceof IndexableField f) { BytesRefBuilder bytesRefBuilder = new BytesRefBuilder(); Number n = f.numericValue(); if (n != null) { diff --git a/solr/core/src/java/org/apache/solr/response/transform/GeoTransformerFactory.java b/solr/core/src/java/org/apache/solr/response/transform/GeoTransformerFactory.java index 443426a1d68..725a2d2b52a 100644 --- a/solr/core/src/java/org/apache/solr/response/transform/GeoTransformerFactory.java +++ b/solr/core/src/java/org/apache/solr/response/transform/GeoTransformerFactory.java @@ -95,7 +95,7 @@ public DocTransformer create( ErrorCode.BAD_REQUEST, this.getClass().getSimpleName() + " using unknown field: " + fname); } - if (!(sf.getType() instanceof AbstractSpatialFieldType)) { + if (!(sf.getType() instanceof AbstractSpatialFieldType sdv)) { throw new SolrException( ErrorCode.BAD_REQUEST, "GeoTransformer requested non-spatial field: " @@ -111,7 +111,6 @@ public DocTransformer create( updater.display_error = display + "_error"; final ShapeValuesSource shapes; - AbstractSpatialFieldType sdv = (AbstractSpatialFieldType) sf.getType(); SpatialStrategy strategy = sdv.getStrategy(fname); if (strategy instanceof CompositeSpatialStrategy) { shapes = ((CompositeSpatialStrategy) strategy).getGeometryStrategy().makeShapeValueSource(); diff --git a/solr/core/src/java/org/apache/solr/response/transform/SubQueryAugmenterFactory.java b/solr/core/src/java/org/apache/solr/response/transform/SubQueryAugmenterFactory.java index 713dff67053..a750e6fcde5 100644 --- a/solr/core/src/java/org/apache/solr/response/transform/SubQueryAugmenterFactory.java +++ b/solr/core/src/java/org/apache/solr/response/transform/SubQueryAugmenterFactory.java @@ -274,8 +274,7 @@ private Collection mapToDocField(String param) { private String convertFieldValue(Object val) { - if (val instanceof IndexableField) { - IndexableField f = (IndexableField) val; + if (val instanceof IndexableField f) { return f.stringValue(); } return val.toString(); diff --git a/solr/core/src/java/org/apache/solr/rest/schema/analysis/ManagedSynonymFilterFactory.java b/solr/core/src/java/org/apache/solr/rest/schema/analysis/ManagedSynonymFilterFactory.java index a004c907f20..94fd01114fe 100644 --- a/solr/core/src/java/org/apache/solr/rest/schema/analysis/ManagedSynonymFilterFactory.java +++ b/solr/core/src/java/org/apache/solr/rest/schema/analysis/ManagedSynonymFilterFactory.java @@ -221,8 +221,7 @@ protected boolean applyMapUpdates(Map jsonMap, boolean ignoreCas Set output = cpsm.mappings.get(origTerm); Object val = jsonMap.get(origTerm); // IMPORTANT: use the original - if (val instanceof String) { - String strVal = (String) val; + if (val instanceof String strVal) { if (output == null) { output = new TreeSet<>(); diff --git a/solr/core/src/java/org/apache/solr/rest/schema/analysis/ManagedSynonymGraphFilterFactory.java b/solr/core/src/java/org/apache/solr/rest/schema/analysis/ManagedSynonymGraphFilterFactory.java index 7863ed6fc3b..1d91fb8686f 100644 --- a/solr/core/src/java/org/apache/solr/rest/schema/analysis/ManagedSynonymGraphFilterFactory.java +++ b/solr/core/src/java/org/apache/solr/rest/schema/analysis/ManagedSynonymGraphFilterFactory.java @@ -217,8 +217,7 @@ protected boolean applyMapUpdates(Map jsonMap, boolean ignoreCas Set output = cpsm.mappings.get(origTerm); Object val = jsonMap.get(origTerm); // IMPORTANT: use the original - if (val instanceof String) { - String strVal = (String) val; + if (val instanceof String strVal) { if (output == null) { output = new TreeSet<>(); diff --git a/solr/core/src/java/org/apache/solr/schema/BinaryField.java b/solr/core/src/java/org/apache/solr/schema/BinaryField.java index 94bc94fd86f..1659e51f870 100644 --- a/solr/core/src/java/org/apache/solr/schema/BinaryField.java +++ b/solr/core/src/java/org/apache/solr/schema/BinaryField.java @@ -112,8 +112,7 @@ private static BytesRef getBytesRef(Object val) { if (val instanceof byte[]) { buf = (byte[]) val; len = buf.length; - } else if (val instanceof ByteBuffer && ((ByteBuffer) val).hasArray()) { - ByteBuffer byteBuf = (ByteBuffer) val; + } else if (val instanceof ByteBuffer byteBuf && byteBuf.hasArray()) { buf = byteBuf.array(); offset = byteBuf.arrayOffset() + byteBuf.position(); len = byteBuf.limit() - byteBuf.position(); @@ -156,8 +155,7 @@ protected void checkSupportsDocValues() { // we support DocValues public Object toNativeType(Object val) { if (val instanceof byte[]) { return ByteBuffer.wrap((byte[]) val); - } else if (val instanceof CharSequence) { - final CharSequence valAsCharSequence = (CharSequence) val; + } else if (val instanceof CharSequence valAsCharSequence) { return ByteBuffer.wrap(Base64.getDecoder().decode(valAsCharSequence.toString())); } return super.toNativeType(val); diff --git a/solr/core/src/java/org/apache/solr/schema/CurrencyFieldType.java b/solr/core/src/java/org/apache/solr/schema/CurrencyFieldType.java index dc4cc1eac79..1b4bf4574ba 100644 --- a/solr/core/src/java/org/apache/solr/schema/CurrencyFieldType.java +++ b/solr/core/src/java/org/apache/solr/schema/CurrencyFieldType.java @@ -515,9 +515,7 @@ public String description() { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof ConvertedCurrencyValueSource)) return false; - - ConvertedCurrencyValueSource that = (ConvertedCurrencyValueSource) o; + if (!(o instanceof ConvertedCurrencyValueSource that)) return false; return Objects.equals(source, that.source) && (rate == that.rate) @@ -728,9 +726,7 @@ public String description() { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof RawCurrencyValueSource)) return false; - - RawCurrencyValueSource that = (RawCurrencyValueSource) o; + if (!(o instanceof RawCurrencyValueSource that)) return false; return Objects.equals(amountValues, that.amountValues) && Objects.equals(currencyValues, that.currencyValues) diff --git a/solr/core/src/java/org/apache/solr/schema/DateRangeField.java b/solr/core/src/java/org/apache/solr/schema/DateRangeField.java index d7a91a41383..880473d68ab 100644 --- a/solr/core/src/java/org/apache/solr/schema/DateRangeField.java +++ b/solr/core/src/java/org/apache/solr/schema/DateRangeField.java @@ -75,8 +75,7 @@ public List createFields(SchemaField field, Object val) { protected String getStoredValue(Shape shape, String shapeStr) { // even if shapeStr is set, it might have included some dateMath, so see if we can resolve it // first: - if (shape instanceof UnitNRShape) { - UnitNRShape unitShape = (UnitNRShape) shape; + if (shape instanceof UnitNRShape unitShape) { if (unitShape.getLevel() == tree.getMaxLevels()) { // fully precise date. We can be fully compatible with DatePointField (incl. 'Z') return shape.toString() + 'Z'; diff --git a/solr/core/src/java/org/apache/solr/schema/ExternalFileFieldReloader.java b/solr/core/src/java/org/apache/solr/schema/ExternalFileFieldReloader.java index 63d546d645a..10f4945ed40 100644 --- a/solr/core/src/java/org/apache/solr/schema/ExternalFileFieldReloader.java +++ b/solr/core/src/java/org/apache/solr/schema/ExternalFileFieldReloader.java @@ -79,8 +79,7 @@ public void cacheFieldSources(IndexSchema schema) { fieldSources.clear(); for (SchemaField field : schema.getFields().values()) { FieldType type = field.getType(); - if (type instanceof ExternalFileField) { - ExternalFileField eff = (ExternalFileField) type; + if (type instanceof ExternalFileField eff) { fieldSources.add(eff.getFileFloatSource(field, datadir)); if (log.isInfoEnabled()) { log.info("Adding ExternalFileFieldReloader listener for field {}", field.getName()); diff --git a/solr/core/src/java/org/apache/solr/schema/FieldType.java b/solr/core/src/java/org/apache/solr/schema/FieldType.java index cb60b1f332a..472f6b4775c 100644 --- a/solr/core/src/java/org/apache/solr/schema/FieldType.java +++ b/solr/core/src/java/org/apache/solr/schema/FieldType.java @@ -1311,9 +1311,8 @@ protected Map getNonFieldPropertyArgs() { protected static SimpleOrderedMap getAnalyzerProperties(Analyzer analyzer) { SimpleOrderedMap analyzerProps = new SimpleOrderedMap<>(); - if (analyzer instanceof TokenizerChain) { + if (analyzer instanceof TokenizerChain tokenizerChain) { Map factoryArgs; - TokenizerChain tokenizerChain = (TokenizerChain) analyzer; CharFilterFactory[] charFilterFactories = tokenizerChain.getCharFilterFactories(); if (0 < charFilterFactories.length) { List> charFilterProps = new ArrayList<>(); diff --git a/solr/core/src/java/org/apache/solr/schema/FileExchangeRateProvider.java b/solr/core/src/java/org/apache/solr/schema/FileExchangeRateProvider.java index 18318770c1c..62161d87dcc 100644 --- a/solr/core/src/java/org/apache/solr/schema/FileExchangeRateProvider.java +++ b/solr/core/src/java/org/apache/solr/schema/FileExchangeRateProvider.java @@ -132,9 +132,7 @@ private void addRate( @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof FileExchangeRateProvider)) return false; - - FileExchangeRateProvider that = (FileExchangeRateProvider) o; + if (!(o instanceof FileExchangeRateProvider that)) return false; return Objects.equals(rates, that.rates); } diff --git a/solr/core/src/java/org/apache/solr/schema/IndexSchema.java b/solr/core/src/java/org/apache/solr/schema/IndexSchema.java index 06dad3175dc..9cd757571fd 100644 --- a/solr/core/src/java/org/apache/solr/schema/IndexSchema.java +++ b/solr/core/src/java/org/apache/solr/schema/IndexSchema.java @@ -2017,8 +2017,7 @@ private void informResourceLoaderAwareObjectsForFieldType(FieldType fieldType) { informResourceLoaderAwareObjectsInChain((TokenizerChain) queryAnalyzer); // if fieldType is a TextField, it might have a multi-term analyzer - if (fieldType instanceof TextField) { - TextField textFieldType = (TextField) fieldType; + if (fieldType instanceof TextField textFieldType) { Analyzer multiTermAnalyzer = textFieldType.getMultiTermAnalyzer(); if (multiTermAnalyzer != null && multiTermAnalyzer != indexAnalyzer diff --git a/solr/core/src/java/org/apache/solr/schema/IndexSchemaFactory.java b/solr/core/src/java/org/apache/solr/schema/IndexSchemaFactory.java index 0300f9bba03..8a984874538 100644 --- a/solr/core/src/java/org/apache/solr/schema/IndexSchemaFactory.java +++ b/solr/core/src/java/org/apache/solr/schema/IndexSchemaFactory.java @@ -168,8 +168,7 @@ public static VersionedConfig getFromCache( return c.get(); }; - if (loader instanceof ZkSolrResourceLoader) { - ZkSolrResourceLoader zkLoader = (ZkSolrResourceLoader) loader; + if (loader instanceof ZkSolrResourceLoader zkLoader) { ObjectCache objectCache = objectCacheSupplier.get(); if (objectCache == null) return cfgLoader.get(); Map confCache = diff --git a/solr/core/src/java/org/apache/solr/schema/LatLonPointSpatialField.java b/solr/core/src/java/org/apache/solr/schema/LatLonPointSpatialField.java index 5010ba27075..f484c28d330 100644 --- a/solr/core/src/java/org/apache/solr/schema/LatLonPointSpatialField.java +++ b/solr/core/src/java/org/apache/solr/schema/LatLonPointSpatialField.java @@ -138,12 +138,11 @@ public LatLonPointSpatialStrategy( @Override public Field[] createIndexableFields(Shape shape) { - if (!(shape instanceof Point)) { + if (!(shape instanceof Point point)) { throw new SolrException( SolrException.ErrorCode.BAD_REQUEST, getClass().getSimpleName() + " only supports indexing points; got: " + shape); } - Point point = (Point) shape; int fieldsLen = (indexed ? 1 : 0) + (docValues ? 1 : 0); Field[] fields = new Field[fieldsLen]; @@ -179,17 +178,14 @@ public Query makeQuery(SpatialArgs args) { // Uses LatLonPoint protected Query makeQueryFromIndex(Shape shape) { // note: latitude then longitude order for LLP's methods - if (shape instanceof Circle) { - Circle circle = (Circle) shape; + if (shape instanceof Circle circle) { double radiusMeters = circle.getRadius() * DistanceUtils.DEG_TO_KM * 1000; return LatLonPoint.newDistanceQuery( getFieldName(), circle.getCenter().getY(), circle.getCenter().getX(), radiusMeters); - } else if (shape instanceof Rectangle) { - Rectangle rect = (Rectangle) shape; + } else if (shape instanceof Rectangle rect) { return LatLonPoint.newBoxQuery( getFieldName(), rect.getMinY(), rect.getMaxY(), rect.getMinX(), rect.getMaxX()); - } else if (shape instanceof Point) { - Point point = (Point) shape; + } else if (shape instanceof Point point) { return LatLonPoint.newDistanceQuery(getFieldName(), point.getY(), point.getX(), 0); } else { throw new UnsupportedOperationException( @@ -204,17 +200,14 @@ protected Query makeQueryFromIndex(Shape shape) { // Uses DocValuesField (otherwise identical to above) protected Query makeQueryFromDocValues(Shape shape) { // note: latitude then longitude order for LLP's methods - if (shape instanceof Circle) { - Circle circle = (Circle) shape; + if (shape instanceof Circle circle) { double radiusMeters = circle.getRadius() * DistanceUtils.DEG_TO_KM * 1000; return LatLonDocValuesField.newSlowDistanceQuery( getFieldName(), circle.getCenter().getY(), circle.getCenter().getX(), radiusMeters); - } else if (shape instanceof Rectangle) { - Rectangle rect = (Rectangle) shape; + } else if (shape instanceof Rectangle rect) { return LatLonDocValuesField.newSlowBoxQuery( getFieldName(), rect.getMinY(), rect.getMaxY(), rect.getMinX(), rect.getMaxX()); - } else if (shape instanceof Point) { - Point point = (Point) shape; + } else if (shape instanceof Point point) { return LatLonDocValuesField.newSlowDistanceQuery( getFieldName(), point.getY(), point.getX(), 0); } else { @@ -258,8 +251,7 @@ private static class DistanceSortValueSource extends DoubleValuesSource { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof DistanceSortValueSource)) return false; - DistanceSortValueSource that = (DistanceSortValueSource) o; + if (!(o instanceof DistanceSortValueSource that)) return false; return Double.compare(that.multiplier, multiplier) == 0 && Objects.equals(fieldName, that.fieldName) && Objects.equals(queryPoint, that.queryPoint); diff --git a/solr/core/src/java/org/apache/solr/schema/ManagedIndexSchemaFactory.java b/solr/core/src/java/org/apache/solr/schema/ManagedIndexSchemaFactory.java index a4e737d364f..55f4164551b 100644 --- a/solr/core/src/java/org/apache/solr/schema/ManagedIndexSchemaFactory.java +++ b/solr/core/src/java/org/apache/solr/schema/ManagedIndexSchemaFactory.java @@ -209,12 +209,11 @@ public ManagedIndexSchema create( } int schemaZkVersion = -1; - if (!(loader instanceof ZkSolrResourceLoader)) { + if (!(loader instanceof ZkSolrResourceLoader zkLoader)) { Entry localSchemaInput = readSchemaLocally(); loadedResource = localSchemaInput.getKey(); schemaInputStream = localSchemaInput.getValue(); } else { // ZooKeeper - final ZkSolrResourceLoader zkLoader = (ZkSolrResourceLoader) loader; final SolrZkClient zkClient = zkLoader.getZkController().getZkClient(); final String managedSchemaPath = lookupZKManagedSchemaPath(); managedSchemaResourceName = @@ -347,8 +346,7 @@ private void warnIfNonManagedSchemaExists() { if (!resourceName.equals(managedSchemaResourceName)) { boolean exists = false; SolrResourceLoader loader = config.getResourceLoader(); - if (loader instanceof ZkSolrResourceLoader) { - ZkSolrResourceLoader zkLoader = (ZkSolrResourceLoader) loader; + if (loader instanceof ZkSolrResourceLoader zkLoader) { String nonManagedSchemaPath = zkLoader.getConfigSetZkPath() + "/" + resourceName; try { exists = zkLoader.getZkController().pathExists(nonManagedSchemaPath); @@ -544,9 +542,8 @@ public Object getSchemaUpdateLock() { @Override public void inform(SolrCore core) { this.core = core; - if (loader instanceof ZkSolrResourceLoader) { + if (loader instanceof ZkSolrResourceLoader zkLoader) { this.zkIndexSchemaReader = new ZkIndexSchemaReader(this, core); - ZkSolrResourceLoader zkLoader = (ZkSolrResourceLoader) loader; zkLoader.setZkIndexSchemaReader(this.zkIndexSchemaReader); try { zkIndexSchemaReader.refreshSchemaFromZk(-1); // update immediately if newer is available diff --git a/solr/core/src/java/org/apache/solr/schema/OpenExchangeRatesOrgProvider.java b/solr/core/src/java/org/apache/solr/schema/OpenExchangeRatesOrgProvider.java index fcc64b111eb..a17dd6fc78b 100644 --- a/solr/core/src/java/org/apache/solr/schema/OpenExchangeRatesOrgProvider.java +++ b/solr/core/src/java/org/apache/solr/schema/OpenExchangeRatesOrgProvider.java @@ -122,9 +122,8 @@ private void reloadIfExpired() { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof OpenExchangeRatesOrgProvider)) return false; + if (!(o instanceof OpenExchangeRatesOrgProvider that)) return false; - OpenExchangeRatesOrgProvider that = (OpenExchangeRatesOrgProvider) o; return Objects.equals(rates, that.rates); } diff --git a/solr/core/src/java/org/apache/solr/schema/RandomSortField.java b/solr/core/src/java/org/apache/solr/schema/RandomSortField.java index 1330832676e..5942e69a684 100644 --- a/solr/core/src/java/org/apache/solr/schema/RandomSortField.java +++ b/solr/core/src/java/org/apache/solr/schema/RandomSortField.java @@ -192,8 +192,7 @@ public int intVal(int doc) { @Override public boolean equals(Object o) { - if (!(o instanceof RandomValueSource)) return false; - RandomValueSource other = (RandomValueSource) o; + if (!(o instanceof RandomValueSource other)) return false; return this.field.equals(other.field); } diff --git a/solr/core/src/java/org/apache/solr/schema/RptWithGeometrySpatialField.java b/solr/core/src/java/org/apache/solr/schema/RptWithGeometrySpatialField.java index ce9a7e04669..ddd814121fa 100644 --- a/solr/core/src/java/org/apache/solr/schema/RptWithGeometrySpatialField.java +++ b/solr/core/src/java/org/apache/solr/schema/RptWithGeometrySpatialField.java @@ -134,9 +134,8 @@ public String toString() { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof CachingShapeValuesource)) return false; + if (!(o instanceof CachingShapeValuesource that)) return false; - CachingShapeValuesource that = (CachingShapeValuesource) o; return Objects.equals(targetValueSource, that.targetValueSource) && Objects.equals(fieldName, that.fieldName); } @@ -217,9 +216,7 @@ private PerSegCacheKey(Object segCoreKey, int docId) { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof PerSegCacheKey)) return false; - - PerSegCacheKey that = (PerSegCacheKey) o; + if (!(o instanceof PerSegCacheKey that)) return false; if (docId != that.docId) return false; diff --git a/solr/core/src/java/org/apache/solr/schema/SchemaManager.java b/solr/core/src/java/org/apache/solr/schema/SchemaManager.java index 53a3bbff40c..b30293efb1a 100644 --- a/solr/core/src/java/org/apache/solr/schema/SchemaManager.java +++ b/solr/core/src/java/org/apache/solr/schema/SchemaManager.java @@ -120,8 +120,7 @@ private List> doOperations(List operations errors = CommandOperation.captureErrors(operations); if (!errors.isEmpty()) break; SolrResourceLoader loader = req.getCore().getResourceLoader(); - if (loader instanceof ZkSolrResourceLoader) { - ZkSolrResourceLoader zkLoader = (ZkSolrResourceLoader) loader; + if (loader instanceof ZkSolrResourceLoader zkLoader) { StringWriter sw = new StringWriter(); try { managedIndexSchema.persist(sw); @@ -484,8 +483,7 @@ private ManagedIndexSchema getFreshManagedSchema(SolrCore core) SolrResourceLoader resourceLoader = core.getResourceLoader(); String schemaResourceName = core.getLatestSchema().getResourceName(); - if (resourceLoader instanceof ZkSolrResourceLoader) { - final ZkSolrResourceLoader zkLoader = (ZkSolrResourceLoader) resourceLoader; + if (resourceLoader instanceof ZkSolrResourceLoader zkLoader) { SolrZkClient zkClient = zkLoader.getZkController().getZkClient(); String managedSchemaPath = zkLoader.getConfigSetZkPath() + "/" + schemaResourceName; try { diff --git a/solr/core/src/java/org/apache/solr/schema/SortableTextField.java b/solr/core/src/java/org/apache/solr/schema/SortableTextField.java index 9bc6a3f7cb9..6e120dddb5c 100644 --- a/solr/core/src/java/org/apache/solr/schema/SortableTextField.java +++ b/solr/core/src/java/org/apache/solr/schema/SortableTextField.java @@ -101,8 +101,7 @@ public List createFields(SchemaField field, Object value) { if (!field.hasDocValues()) { return Collections.singletonList(f); } - if (value instanceof ByteArrayUtf8CharSequence) { - ByteArrayUtf8CharSequence utf8 = (ByteArrayUtf8CharSequence) value; + if (value instanceof ByteArrayUtf8CharSequence utf8) { if (utf8.size() < maxCharsForDocValues) { BytesRef bytes = new BytesRef(utf8.getBuf(), utf8.offset(), utf8.size()); return getIndexableFields(field, f, bytes); diff --git a/solr/core/src/java/org/apache/solr/schema/StrField.java b/solr/core/src/java/org/apache/solr/schema/StrField.java index 114de6bcaca..a5f7b4643f9 100644 --- a/solr/core/src/java/org/apache/solr/schema/StrField.java +++ b/solr/core/src/java/org/apache/solr/schema/StrField.java @@ -69,8 +69,7 @@ public List createFields(SchemaField field, Object value) { } public static BytesRef getBytesRef(Object value) { - if (value instanceof ByteArrayUtf8CharSequence) { - ByteArrayUtf8CharSequence utf8 = (ByteArrayUtf8CharSequence) value; + if (value instanceof ByteArrayUtf8CharSequence utf8) { return new BytesRef(utf8.getBuf(), utf8.offset(), utf8.size()); } else return new BytesRef(value.toString()); } diff --git a/solr/core/src/java/org/apache/solr/schema/TrieField.java b/solr/core/src/java/org/apache/solr/schema/TrieField.java index 946af8c8eb9..02926704c21 100644 --- a/solr/core/src/java/org/apache/solr/schema/TrieField.java +++ b/solr/core/src/java/org/apache/solr/schema/TrieField.java @@ -697,8 +697,7 @@ public List createFields(SchemaField sf, Object value) { * prefix of the main value of a trie field that indexes multiple precisions per value. */ public static String getMainValuePrefix(org.apache.solr.schema.FieldType ft) { - if (ft instanceof TrieField) { - final TrieField trie = (TrieField) ft; + if (ft instanceof TrieField trie) { if (trie.precisionStep == Integer.MAX_VALUE) return null; switch (trie.type) { case INTEGER: diff --git a/solr/core/src/java/org/apache/solr/schema/ZkIndexSchemaReader.java b/solr/core/src/java/org/apache/solr/schema/ZkIndexSchemaReader.java index faf496789f8..3112bdced58 100644 --- a/solr/core/src/java/org/apache/solr/schema/ZkIndexSchemaReader.java +++ b/solr/core/src/java/org/apache/solr/schema/ZkIndexSchemaReader.java @@ -257,8 +257,7 @@ public int hashCode() { public boolean equals(Object other) { if (other == null) return false; if (other == this) return true; - if (!(other instanceof ZkIndexSchemaReader)) return false; - ZkIndexSchemaReader that = (ZkIndexSchemaReader) other; + if (!(other instanceof ZkIndexSchemaReader that)) return false; return this.managedSchemaPath.equals(that.managedSchemaPath) && this.uniqueCoreId.equals(that.uniqueCoreId); } diff --git a/solr/core/src/java/org/apache/solr/search/BitDocSet.java b/solr/core/src/java/org/apache/solr/search/BitDocSet.java index 831de78cb47..c45cbd5d893 100644 --- a/solr/core/src/java/org/apache/solr/search/BitDocSet.java +++ b/solr/core/src/java/org/apache/solr/search/BitDocSet.java @@ -224,8 +224,7 @@ protected static void andNot(FixedBitSet bits, DocSet other) { @Override public DocSet union(DocSet other) { FixedBitSet newbits = bits.clone(); - if (other instanceof BitDocSet) { - BitDocSet otherDocSet = (BitDocSet) other; + if (other instanceof BitDocSet otherDocSet) { newbits = FixedBitSet.ensureCapacity(newbits, otherDocSet.bits.length()); newbits.or(otherDocSet.bits); } else { diff --git a/solr/core/src/java/org/apache/solr/search/CollapsingQParserPlugin.java b/solr/core/src/java/org/apache/solr/search/CollapsingQParserPlugin.java index 221f2c8b06b..119cc422a1e 100644 --- a/solr/core/src/java/org/apache/solr/search/CollapsingQParserPlugin.java +++ b/solr/core/src/java/org/apache/solr/search/CollapsingQParserPlugin.java @@ -249,8 +249,7 @@ private GroupHeadSelector(String s, GroupHeadSelectorType type) { @Override public boolean equals(final Object other) { - if (other instanceof GroupHeadSelector) { - final GroupHeadSelector that = (GroupHeadSelector) other; + if (other instanceof GroupHeadSelector that) { return (this.type == that.type) && this.selectorText.equals(that.selectorText); } return false; diff --git a/solr/core/src/java/org/apache/solr/search/DisMaxQParser.java b/solr/core/src/java/org/apache/solr/search/DisMaxQParser.java index b6ae705704e..9f90831e820 100644 --- a/solr/core/src/java/org/apache/solr/search/DisMaxQParser.java +++ b/solr/core/src/java/org/apache/solr/search/DisMaxQParser.java @@ -151,8 +151,7 @@ protected void addBoostQuery(BooleanQuery.Builder query, SolrParams solrParams) if (1 == boostQueries.size() && 1 == boostParams.length) { /* legacy logic */ Query f = boostQueries.get(0); - while (f instanceof BoostQuery) { - BoostQuery bq = (BoostQuery) f; + while (f instanceof BoostQuery bq) { if (bq.getBoost() == 1f) { f = bq.getQuery(); } else { diff --git a/solr/core/src/java/org/apache/solr/search/ExtendedDismaxQParser.java b/solr/core/src/java/org/apache/solr/search/ExtendedDismaxQParser.java index 3d593669ed5..535e2c493bf 100644 --- a/solr/core/src/java/org/apache/solr/search/ExtendedDismaxQParser.java +++ b/solr/core/src/java/org/apache/solr/search/ExtendedDismaxQParser.java @@ -1236,8 +1236,7 @@ && allSameQueryStructure(lst)) { subs.clear(); // Make a dismax query for each clause position in the boolean per-field queries. for (int n = 0; n < lst.size(); ++n) { - if (lst.get(n) instanceof BoostQuery) { - BoostQuery boostQuery = (BoostQuery) lst.get(n); + if (lst.get(n) instanceof BoostQuery boostQuery) { BooleanQuery booleanQuery = (BooleanQuery) boostQuery.getQuery(); subs.add( new BoostQuery( @@ -1440,8 +1439,7 @@ private Query getQuery() { BooleanQuery bq = (BooleanQuery) query; query = SolrPluginUtils.setMinShouldMatch(bq, minShouldMatch, false); } - } else if (query instanceof PhraseQuery) { - PhraseQuery pq = (PhraseQuery) query; + } else if (query instanceof PhraseQuery pq) { if (minClauseSize > 1 && pq.getTerms().length < minClauseSize) return null; PhraseQuery.Builder builder = new PhraseQuery.Builder(); Term[] terms = pq.getTerms(); @@ -1451,8 +1449,7 @@ private Query getQuery() { } builder.setSlop(slop); query = builder.build(); - } else if (query instanceof MultiPhraseQuery) { - MultiPhraseQuery mpq = (MultiPhraseQuery) query; + } else if (query instanceof MultiPhraseQuery mpq) { if (minClauseSize > 1 && mpq.getTermArrays().length < minClauseSize) return null; if (slop != mpq.getSlop()) { query = new MultiPhraseQuery.Builder(mpq).setSlop(slop).build(); @@ -1485,16 +1482,14 @@ private Query getQuery() { private Analyzer noStopwordFilterAnalyzer(String fieldName) { FieldType ft = parser.getReq().getSchema().getFieldType(fieldName); Analyzer qa = ft.getQueryAnalyzer(); - if (!(qa instanceof TokenizerChain)) { + if (!(qa instanceof TokenizerChain tcq)) { return qa; } - TokenizerChain tcq = (TokenizerChain) qa; Analyzer ia = ft.getIndexAnalyzer(); - if (ia == qa || !(ia instanceof TokenizerChain)) { + if (ia == qa || !(ia instanceof TokenizerChain tci)) { return qa; } - TokenizerChain tci = (TokenizerChain) ia; // make sure that there isn't a stop filter in the indexer for (TokenFilterFactory tf : tci.getTokenFilterFactories()) { diff --git a/solr/core/src/java/org/apache/solr/search/FloatPayloadValueSource.java b/solr/core/src/java/org/apache/solr/search/FloatPayloadValueSource.java index d6572edd31d..a8f5b5112ea 100644 --- a/solr/core/src/java/org/apache/solr/search/FloatPayloadValueSource.java +++ b/solr/core/src/java/org/apache/solr/search/FloatPayloadValueSource.java @@ -221,9 +221,8 @@ public String description() { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof FloatPayloadValueSource)) return false; + if (!(o instanceof FloatPayloadValueSource that)) return false; - FloatPayloadValueSource that = (FloatPayloadValueSource) o; return Objects.equals(indexedField, that.indexedField) && Objects.equals(indexedBytes, that.indexedBytes) && Objects.equals(decoder, that.decoder) diff --git a/solr/core/src/java/org/apache/solr/search/FunctionQParser.java b/solr/core/src/java/org/apache/solr/search/FunctionQParser.java index 2a3dcd9dc68..97b1fb35d22 100644 --- a/solr/core/src/java/org/apache/solr/search/FunctionQParser.java +++ b/solr/core/src/java/org/apache/solr/search/FunctionQParser.java @@ -424,8 +424,7 @@ protected ValueSource parseValueSource(int flags) throws SyntaxError { valueSource = new FieldNameValueSource(val); } else { QParser subParser = subQuery(val, "func"); - if (subParser instanceof FunctionQParser) { - FunctionQParser subFunc = (FunctionQParser) subParser; + if (subParser instanceof FunctionQParser subFunc) { subFunc.setParseMultipleSources(true); subFunc.setFlags(flags); } diff --git a/solr/core/src/java/org/apache/solr/search/HashQParserPlugin.java b/solr/core/src/java/org/apache/solr/search/HashQParserPlugin.java index 89c012654ee..6ba9a7d66a4 100644 --- a/solr/core/src/java/org/apache/solr/search/HashQParserPlugin.java +++ b/solr/core/src/java/org/apache/solr/search/HashQParserPlugin.java @@ -193,8 +193,7 @@ public boolean needsScores() { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof HashCodeValuesSource)) return false; - HashCodeValuesSource that = (HashCodeValuesSource) o; + if (!(o instanceof HashCodeValuesSource that)) return false; return Arrays.equals(fields, that.fields); } @@ -240,8 +239,7 @@ public boolean test(double hashAsDouble) { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof HashPartitionPredicate)) return false; - HashPartitionPredicate that = (HashPartitionPredicate) o; + if (!(o instanceof HashPartitionPredicate that)) return false; return workers == that.workers && worker == that.worker; } diff --git a/solr/core/src/java/org/apache/solr/search/IGainTermsQParserPlugin.java b/solr/core/src/java/org/apache/solr/search/IGainTermsQParserPlugin.java index 011e22c0f6c..eba8327360a 100644 --- a/solr/core/src/java/org/apache/solr/search/IGainTermsQParserPlugin.java +++ b/solr/core/src/java/org/apache/solr/search/IGainTermsQParserPlugin.java @@ -230,8 +230,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { - if (!(obj instanceof TermWithScore)) return false; - TermWithScore other = (TermWithScore) obj; + if (!(obj instanceof TermWithScore other)) return false; return Objects.equals(this.term, other.term); } diff --git a/solr/core/src/java/org/apache/solr/search/MaxScoreQParser.java b/solr/core/src/java/org/apache/solr/search/MaxScoreQParser.java index 8cbceeefad5..eef5813e953 100644 --- a/solr/core/src/java/org/apache/solr/search/MaxScoreQParser.java +++ b/solr/core/src/java/org/apache/solr/search/MaxScoreQParser.java @@ -54,8 +54,7 @@ public MaxScoreQParser( public Query parse() throws SyntaxError { Query q = super.parse(); float boost = 1f; - if (q instanceof BoostQuery) { - BoostQuery bq = (BoostQuery) q; + if (q instanceof BoostQuery bq) { boost = bq.getBoost(); q = bq.getQuery(); } diff --git a/solr/core/src/java/org/apache/solr/search/MultiThreadedSearcher.java b/solr/core/src/java/org/apache/solr/search/MultiThreadedSearcher.java index c4bdd921e7a..b7b4d7a0325 100644 --- a/solr/core/src/java/org/apache/solr/search/MultiThreadedSearcher.java +++ b/solr/core/src/java/org/apache/solr/search/MultiThreadedSearcher.java @@ -280,8 +280,7 @@ public Collector newCollector() throws IOException { public Object reduce(Collection collectors) throws IOException { final FixedBitSet reduced = new FixedBitSet(maxDoc); for (Object collector : collectors) { - if (collector instanceof FixedBitSetCollector) { - FixedBitSetCollector fixedBitSetCollector = (FixedBitSetCollector) collector; + if (collector instanceof FixedBitSetCollector fixedBitSetCollector) { fixedBitSetCollector.update(reduced); } } diff --git a/solr/core/src/java/org/apache/solr/search/MutableBitDocSet.java b/solr/core/src/java/org/apache/solr/search/MutableBitDocSet.java index 8b1f7301ed2..73b26770353 100644 --- a/solr/core/src/java/org/apache/solr/search/MutableBitDocSet.java +++ b/solr/core/src/java/org/apache/solr/search/MutableBitDocSet.java @@ -50,8 +50,7 @@ public static MutableBitDocSet fromBitDocSet(BitDocSet bitDocSet) { * @return Unwrapped DocSet that is not mutable */ public static DocSet unwrapIfMutable(DocSet docSet) { - if (docSet instanceof MutableBitDocSet) { - MutableBitDocSet mutableBitDocSet = (MutableBitDocSet) docSet; + if (docSet instanceof MutableBitDocSet mutableBitDocSet) { // don't call size() since we just want to pass through the size // instead of computing it if it was already computed return new BitDocSet(mutableBitDocSet.getBits(), mutableBitDocSet.size); diff --git a/solr/core/src/java/org/apache/solr/search/QueryParsing.java b/solr/core/src/java/org/apache/solr/search/QueryParsing.java index 2abe8b8f6d3..5b635029c6f 100644 --- a/solr/core/src/java/org/apache/solr/search/QueryParsing.java +++ b/solr/core/src/java/org/apache/solr/search/QueryParsing.java @@ -230,13 +230,11 @@ public static void toString(Query query, IndexSchema schema, Appendable out, int // clear the boosted / is clause flags for recursion int subflag = flags & ~(FLAG_BOOSTED | FLAG_IS_CLAUSE); - if (query instanceof TermQuery) { - TermQuery q = (TermQuery) query; + if (query instanceof TermQuery q) { Term t = q.getTerm(); FieldType ft = writeFieldName(t.field(), schema, out, flags); writeFieldVal(t.bytes(), ft, out, flags); - } else if (query instanceof TermRangeQuery) { - TermRangeQuery q = (TermRangeQuery) query; + } else if (query instanceof TermRangeQuery q) { String fname = q.getField(); FieldType ft = writeFieldName(fname, schema, out, flags); out.append(q.includesLower() ? '[' : '{'); @@ -257,8 +255,7 @@ public static void toString(Query query, IndexSchema schema, Appendable out, int } out.append(q.includesUpper() ? ']' : '}'); - } else if (query instanceof LegacyNumericRangeQuery) { - LegacyNumericRangeQuery q = (LegacyNumericRangeQuery) query; + } else if (query instanceof LegacyNumericRangeQuery q) { String fname = q.getField(); FieldType ft = writeFieldName(fname, schema, out, flags); out.append(q.includesMin() ? '[' : '{'); @@ -279,8 +276,7 @@ public static void toString(Query query, IndexSchema schema, Appendable out, int } out.append(q.includesMax() ? ']' : '}'); - } else if (query instanceof BooleanQuery) { - BooleanQuery q = (BooleanQuery) query; + } else if (query instanceof BooleanQuery q) { boolean needParens = false; if (q.getMinimumNumberShouldMatch() != 0 || (flags & (FLAG_IS_CLAUSE | FLAG_BOOSTED)) != 0) { @@ -315,8 +311,7 @@ public static void toString(Query query, IndexSchema schema, Appendable out, int out.append(Integer.toString(q.getMinimumNumberShouldMatch())); } - } else if (query instanceof PrefixQuery) { - PrefixQuery q = (PrefixQuery) query; + } else if (query instanceof PrefixQuery q) { Term prefix = q.getPrefix(); FieldType ft = writeFieldName(prefix.field(), schema, out, flags); out.append(prefix.text()); @@ -327,12 +322,10 @@ public static void toString(Query query, IndexSchema schema, Appendable out, int out.append(query.toString()); } else if (query instanceof ConstantScoreQuery) { out.append(query.toString()); - } else if (query instanceof WrappedQuery) { - WrappedQuery q = (WrappedQuery) query; + } else if (query instanceof WrappedQuery q) { out.append(q.getOptions()); toString(q.getWrappedQuery(), schema, out, subflag); - } else if (query instanceof BoostQuery) { - BoostQuery q = (BoostQuery) query; + } else if (query instanceof BoostQuery q) { toString(q.getQuery(), schema, out, subflag | FLAG_BOOSTED); out.append('^'); out.append(Float.toString(q.getBoost())); diff --git a/solr/core/src/java/org/apache/solr/search/QueryResultKey.java b/solr/core/src/java/org/apache/solr/search/QueryResultKey.java index 8d75c5bb6a6..671da8cda54 100644 --- a/solr/core/src/java/org/apache/solr/search/QueryResultKey.java +++ b/solr/core/src/java/org/apache/solr/search/QueryResultKey.java @@ -110,8 +110,7 @@ public int hashCode() { @Override public boolean equals(Object o) { if (o == this) return true; - if (!(o instanceof QueryResultKey)) return false; - QueryResultKey other = (QueryResultKey) o; + if (!(o instanceof QueryResultKey other)) return false; // fast check of the whole hash code... most hash tables will only use // some of the bits, so if this is a hash collision, it's still likely diff --git a/solr/core/src/java/org/apache/solr/search/QueryUtils.java b/solr/core/src/java/org/apache/solr/search/QueryUtils.java index ba02c34819c..954ed91b0d4 100644 --- a/solr/core/src/java/org/apache/solr/search/QueryUtils.java +++ b/solr/core/src/java/org/apache/solr/search/QueryUtils.java @@ -44,8 +44,7 @@ public class QueryUtils { /** return true if this query has no positive components */ public static boolean isNegative(Query q) { - if (!(q instanceof BooleanQuery)) return false; - BooleanQuery bq = (BooleanQuery) q; + if (!(q instanceof BooleanQuery bq)) return false; Collection clauses = bq.clauses(); if (clauses.size() == 0) return false; for (BooleanClause clause : clauses) { @@ -140,8 +139,7 @@ public static void ensurePrefixQueryObeysMinimumPrefixLength( * @return Absolute version of the Query */ public static Query getAbs(Query q) { - if (q instanceof BoostQuery) { - BoostQuery bq = (BoostQuery) q; + if (q instanceof BoostQuery bq) { Query subQ = bq.getQuery(); Query absSubQ = getAbs(subQ); if (absSubQ.equals(subQ)) return q; @@ -155,8 +153,7 @@ public static Query getAbs(Query q) { return new WrappedQuery(absSubQ); } - if (!(q instanceof BooleanQuery)) return q; - BooleanQuery bq = (BooleanQuery) q; + if (!(q instanceof BooleanQuery bq)) return q; Collection clauses = bq.clauses(); if (clauses.size() == 0) return q; @@ -198,8 +195,7 @@ public static Query makeQueryable(Query q) { */ public static Query fixNegativeQuery(Query q) { float boost = 1f; - if (q instanceof BoostQuery) { - BoostQuery bq = (BoostQuery) q; + if (q instanceof BoostQuery bq) { boost = bq.getBoost(); q = bq.getQuery(); } @@ -326,8 +322,7 @@ public static Set getTaggedQueries(SolrQueryRequest req, Collection) tagVal) { - if (!(obj instanceof QParser)) continue; - QParser qParser = (QParser) obj; + if (!(obj instanceof QParser qParser)) continue; Query query; try { query = qParser.getQuery(); diff --git a/solr/core/src/java/org/apache/solr/search/ReRankScaler.java b/solr/core/src/java/org/apache/solr/search/ReRankScaler.java index 8410467ddf8..3a03e13fc65 100644 --- a/solr/core/src/java/org/apache/solr/search/ReRankScaler.java +++ b/solr/core/src/java/org/apache/solr/search/ReRankScaler.java @@ -84,8 +84,7 @@ public int hashCode() { @Override public boolean equals(Object o) { - if (o instanceof ReRankScaler) { - ReRankScaler _reRankScaler = (ReRankScaler) o; + if (o instanceof ReRankScaler _reRankScaler) { if (mainQueryMin == _reRankScaler.mainQueryMin && mainQueryMax == _reRankScaler.mainQueryMax && reRankQueryMin == _reRankScaler.reRankQueryMin diff --git a/solr/core/src/java/org/apache/solr/search/SignificantTermsQParserPlugin.java b/solr/core/src/java/org/apache/solr/search/SignificantTermsQParserPlugin.java index 4e6c09f38f6..3fdb46ee5a2 100644 --- a/solr/core/src/java/org/apache/solr/search/SignificantTermsQParserPlugin.java +++ b/solr/core/src/java/org/apache/solr/search/SignificantTermsQParserPlugin.java @@ -291,8 +291,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { - if (!(obj instanceof TermWithScore)) return false; - TermWithScore other = (TermWithScore) obj; + if (!(obj instanceof TermWithScore other)) return false; return Objects.equals(this.term, other.term); } diff --git a/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java b/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java index 3c8afde39ff..19f93cc49fa 100644 --- a/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java +++ b/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java @@ -1230,8 +1230,7 @@ public ProcessedFilter getProcessedFilter(List queries) throws IOExceptio int end = 0; // size of "sets" and "neg"; parallel arrays for (Query q : queries) { - if (q instanceof ExtendedQuery) { - ExtendedQuery eq = (ExtendedQuery) q; + if (q instanceof ExtendedQuery eq) { if (!eq.getCache()) { if (eq.getCost() >= 100 && eq instanceof PostFilter) { if (postFilters == null) postFilters = new ArrayList<>(sets.length - end); @@ -1608,8 +1607,7 @@ private QueryResult getDocListC(QueryResult qr, QueryCommand cmd) throws IOExcep int flags = cmd.getFlags(); Query q = cmd.getQuery(); - if (q instanceof ExtendedQuery) { - ExtendedQuery eq = (ExtendedQuery) q; + if (q instanceof ExtendedQuery eq) { if (!eq.getCache()) { flags |= (NO_CHECK_QCACHE | NO_SET_QCACHE | NO_CHECK_FILTERCACHE); } @@ -1858,8 +1856,7 @@ TopDocsCollector buildTopDocsCollector(int len, QueryCommand throws IOException { int minNumFound = cmd.getMinExactCount(); Query q = cmd.getQuery(); - if (q instanceof RankQuery) { - RankQuery rq = (RankQuery) q; + if (q instanceof RankQuery rq) { return rq.getTopDocsCollector(len, cmd, this); } diff --git a/solr/core/src/java/org/apache/solr/search/SolrReturnFields.java b/solr/core/src/java/org/apache/solr/search/SolrReturnFields.java index af35245af15..baaaeb270ef 100644 --- a/solr/core/src/java/org/apache/solr/search/SolrReturnFields.java +++ b/solr/core/src/java/org/apache/solr/search/SolrReturnFields.java @@ -381,8 +381,7 @@ private void add( ValueSource vs = null; try { - if (parser instanceof FunctionQParser) { - FunctionQParser fparser = (FunctionQParser) parser; + if (parser instanceof FunctionQParser fparser) { fparser.setParseMultipleSources(false); fparser.setParseToEnd(false); diff --git a/solr/core/src/java/org/apache/solr/search/SortSpecParsing.java b/solr/core/src/java/org/apache/solr/search/SortSpecParsing.java index 6b71f139133..ef012a5fed6 100644 --- a/solr/core/src/java/org/apache/solr/search/SortSpecParsing.java +++ b/solr/core/src/java/org/apache/solr/search/SortSpecParsing.java @@ -115,8 +115,7 @@ private static SortSpec parseSortSpecImpl( QParser parser = QParser.getParser(funcStr, FunctionQParserPlugin.NAME, optionalReq); Query q = null; try { - if (parser instanceof FunctionQParser) { - FunctionQParser fparser = (FunctionQParser) parser; + if (parser instanceof FunctionQParser fparser) { fparser.setParseMultipleSources(false); fparser.setParseToEnd(false); diff --git a/solr/core/src/java/org/apache/solr/search/SpatialFilterQParser.java b/solr/core/src/java/org/apache/solr/search/SpatialFilterQParser.java index 1bb1ca343b0..97224284122 100644 --- a/solr/core/src/java/org/apache/solr/search/SpatialFilterQParser.java +++ b/solr/core/src/java/org/apache/solr/search/SpatialFilterQParser.java @@ -73,8 +73,7 @@ public Query parse() throws SyntaxError { SchemaField sf = req.getSchema().getField(fields[0]); FieldType type = sf.getType(); - if (type instanceof SpatialQueryable) { - SpatialQueryable queryable = ((SpatialQueryable) type); + if (type instanceof SpatialQueryable queryable) { double radius = localParams.getDouble(SpatialParams.SPHERE_RADIUS, queryable.getSphereRadius()); SpatialOptions opts = new SpatialOptions(pointStr, dist, sf, measStr, radius); diff --git a/solr/core/src/java/org/apache/solr/search/TopLevelJoinQuery.java b/solr/core/src/java/org/apache/solr/search/TopLevelJoinQuery.java index ea7b55a2e75..ce05a02eb95 100644 --- a/solr/core/src/java/org/apache/solr/search/TopLevelJoinQuery.java +++ b/solr/core/src/java/org/apache/solr/search/TopLevelJoinQuery.java @@ -56,14 +56,13 @@ public TopLevelJoinQuery(String fromField, String toField, String coreName, Quer @Override public Weight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float boost) throws IOException { - if (!(searcher instanceof SolrIndexSearcher)) { + if (!(searcher instanceof SolrIndexSearcher solrSearcher)) { log.debug( "Falling back to JoinQueryWeight because searcher [{}] is not the required SolrIndexSearcher", searcher); return super.createWeight(searcher, scoreMode, boost); } - final SolrIndexSearcher solrSearcher = (SolrIndexSearcher) searcher; final JoinQueryWeight weight = new JoinQueryWeight(solrSearcher, ScoreMode.COMPLETE_NO_SCORES, 1.0f); final SolrIndexSearcher fromSearcher = weight.fromSearcher; diff --git a/solr/core/src/java/org/apache/solr/search/ValueSourceParser.java b/solr/core/src/java/org/apache/solr/search/ValueSourceParser.java index 3e4a720e5ce..2cd071a8938 100644 --- a/solr/core/src/java/org/apache/solr/search/ValueSourceParser.java +++ b/solr/core/src/java/org/apache/solr/search/ValueSourceParser.java @@ -541,12 +541,11 @@ public ValueSource parse(FunctionQParser fp) throws SyntaxError { String fieldName = fp.parseArg(); SchemaField f = fp.getReq().getSchema().getField(fieldName); - if (!(f.getType() instanceof CurrencyFieldType)) { + if (!(f.getType() instanceof CurrencyFieldType ft)) { throw new SolrException( SolrException.ErrorCode.BAD_REQUEST, "Currency function input must be the name of a CurrencyFieldType: " + fieldName); } - CurrencyFieldType ft = (CurrencyFieldType) f.getType(); String code = fp.hasMoreArguments() ? fp.parseArg() : null; return ft.getConvertedValueSource(code, ft.getValueSource(f, fp)); } @@ -1606,8 +1605,7 @@ public int hashCode() { @Override public boolean equals(Object o) { - if (!(o instanceof LongConstValueSource)) return false; - LongConstValueSource other = (LongConstValueSource) o; + if (!(o instanceof LongConstValueSource other)) return false; return this.constant == other.constant; } @@ -1759,8 +1757,7 @@ public int hashCode() { @Override public boolean equals(Object o) { - if (!(o instanceof Function)) return false; - Function other = (Function) o; + if (!(o instanceof Function other)) return false; return this.a.equals(other.a) && this.b.equals(other.b); } } @@ -1799,8 +1796,7 @@ public int hashCode() { @Override public boolean equals(Object o) { - if (!(o instanceof BoolConstValueSource)) return false; - BoolConstValueSource other = (BoolConstValueSource) o; + if (!(o instanceof BoolConstValueSource other)) return false; return this.constant == other.constant; } diff --git a/solr/core/src/java/org/apache/solr/search/facet/FacetFieldProcessor.java b/solr/core/src/java/org/apache/solr/search/facet/FacetFieldProcessor.java index ff3a2553ca4..3e8d3020294 100644 --- a/solr/core/src/java/org/apache/solr/search/facet/FacetFieldProcessor.java +++ b/solr/core/src/java/org/apache/solr/search/facet/FacetFieldProcessor.java @@ -895,8 +895,8 @@ public SlotAcc registerSweepingAccs(SweepingCountSlotAcc baseSweepingAcc) { * @see SweepingCountSlotAcc */ protected boolean registerSweepingAccIfSupportedByCollectAcc() { - if (countAcc instanceof SweepingCountSlotAcc && collectAcc instanceof SweepableSlotAcc) { - final SweepingCountSlotAcc sweepingCountAcc = (SweepingCountSlotAcc) countAcc; + if (countAcc instanceof SweepingCountSlotAcc sweepingCountAcc + && collectAcc instanceof SweepableSlotAcc) { collectAcc = ((SweepableSlotAcc) collectAcc).registerSweepingAccs(sweepingCountAcc); if (allBucketsAcc != null) { allBucketsAcc.collectAcc = collectAcc; diff --git a/solr/core/src/java/org/apache/solr/search/facet/FacetFieldProcessorByArrayDV.java b/solr/core/src/java/org/apache/solr/search/facet/FacetFieldProcessorByArrayDV.java index cb7d5492a91..6dde1e24c85 100644 --- a/solr/core/src/java/org/apache/solr/search/facet/FacetFieldProcessorByArrayDV.java +++ b/solr/core/src/java/org/apache/solr/search/facet/FacetFieldProcessorByArrayDV.java @@ -225,9 +225,7 @@ private void collectPerSeg(SortedDocValues singleDv, SweepDISI disi, LongValues // calculate segment-local counts int doc; - if (singleDv instanceof FieldCacheImpl.SortedDocValuesImpl.Iter) { - FieldCacheImpl.SortedDocValuesImpl.Iter fc = - (FieldCacheImpl.SortedDocValuesImpl.Iter) singleDv; + if (singleDv instanceof FieldCacheImpl.SortedDocValuesImpl.Iter fc) { while ((doc = disi.nextDoc()) != DocIdSetIterator.NO_MORE_DOCS) { final int segOrd = fc.getOrd(doc); if (segOrd >= 0) { @@ -340,10 +338,8 @@ private void collectCounts(SortedDocValues singleDv, SweepDISI disi, LongValues throws IOException { final SegCountGlobal segCounter = getSegCountGlobal(disi, singleDv); int doc; - if (singleDv instanceof FieldCacheImpl.SortedDocValuesImpl.Iter) { + if (singleDv instanceof FieldCacheImpl.SortedDocValuesImpl.Iter fc) { - FieldCacheImpl.SortedDocValuesImpl.Iter fc = - (FieldCacheImpl.SortedDocValuesImpl.Iter) singleDv; while ((doc = disi.nextDoc()) != DocIdSetIterator.NO_MORE_DOCS) { int segOrd = fc.getOrd(doc); if (segOrd < 0) continue; diff --git a/solr/core/src/java/org/apache/solr/search/facet/FacetFieldProcessorByHashDV.java b/solr/core/src/java/org/apache/solr/search/facet/FacetFieldProcessorByHashDV.java index 473f70c9d2d..a61230e9242 100644 --- a/solr/core/src/java/org/apache/solr/search/facet/FacetFieldProcessorByHashDV.java +++ b/solr/core/src/java/org/apache/solr/search/facet/FacetFieldProcessorByHashDV.java @@ -369,9 +369,7 @@ public ScoreMode scoreMode() { @Override protected void doSetNextReader(LeafReaderContext ctx) throws IOException { setNextReaderFirstPhase(ctx); - if (globalDocValues instanceof MultiDocValues.MultiSortedDocValues) { - MultiDocValues.MultiSortedDocValues multiDocValues = - (MultiDocValues.MultiSortedDocValues) globalDocValues; + if (globalDocValues instanceof MultiDocValues.MultiSortedDocValues multiDocValues) { docValues = multiDocValues.values[ctx.ord]; toGlobal = multiDocValues.mapping.getGlobalOrds(ctx.ord); } diff --git a/solr/core/src/java/org/apache/solr/search/facet/FacetHeatmap.java b/solr/core/src/java/org/apache/solr/search/facet/FacetHeatmap.java index 4a13ddc51af..57d69d47c52 100644 --- a/solr/core/src/java/org/apache/solr/search/facet/FacetHeatmap.java +++ b/solr/core/src/java/org/apache/solr/search/facet/FacetHeatmap.java @@ -129,13 +129,10 @@ public FacetHeatmap parse(Object argsObj) { final DistanceUnits distanceUnits; // note: the two instanceof conditions is not ideal, versus one. If we start needing to add // more then refactor. - if ((type instanceof AbstractSpatialPrefixTreeFieldType)) { - AbstractSpatialPrefixTreeFieldType rptType = - (AbstractSpatialPrefixTreeFieldType) type; + if ((type instanceof AbstractSpatialPrefixTreeFieldType rptType)) { strategy = rptType.getStrategy(fieldName); distanceUnits = rptType.getDistanceUnits(); - } else if (type instanceof RptWithGeometrySpatialField) { - RptWithGeometrySpatialField rptSdvType = (RptWithGeometrySpatialField) type; + } else if (type instanceof RptWithGeometrySpatialField rptSdvType) { strategy = rptSdvType.getStrategy(fieldName).getIndexStrategy(); distanceUnits = rptSdvType.getDistanceUnits(); } else { diff --git a/solr/core/src/java/org/apache/solr/search/facet/FacetParser.java b/solr/core/src/java/org/apache/solr/search/facet/FacetParser.java index ce1276788d5..92d6ef2fb7d 100644 --- a/solr/core/src/java/org/apache/solr/search/facet/FacetParser.java +++ b/solr/core/src/java/org/apache/solr/search/facet/FacetParser.java @@ -612,8 +612,7 @@ private static FacetRequest.FacetSort parseAndValidateSort( FacetRequest.FacetSort facetSort = null; - if (sort instanceof String) { - String sortStr = (String) sort; + if (sort instanceof String sortStr) { if (sortStr.endsWith(" asc")) { facetSort = new FacetRequest.FacetSort( diff --git a/solr/core/src/java/org/apache/solr/search/facet/FacetRangeProcessor.java b/solr/core/src/java/org/apache/solr/search/facet/FacetRangeProcessor.java index 3bcb5349ff2..554f6f762b3 100644 --- a/solr/core/src/java/org/apache/solr/search/facet/FacetRangeProcessor.java +++ b/solr/core/src/java/org/apache/solr/search/facet/FacetRangeProcessor.java @@ -297,12 +297,11 @@ private void createRangeList() { * @return list of {@link Range} */ private List parseRanges(Object input) { - if (!(input instanceof List)) { + if (!(input instanceof List intervals)) { throw new SolrException( SolrException.ErrorCode.BAD_REQUEST, "Expected List for ranges but got " + input.getClass().getSimpleName() + " = " + input); } - List intervals = (List) input; List ranges = new ArrayList<>(); for (Object obj : intervals) { if (!(obj instanceof Map)) { diff --git a/solr/core/src/java/org/apache/solr/search/facet/FacetRequest.java b/solr/core/src/java/org/apache/solr/search/facet/FacetRequest.java index 5b8fec842c9..55c852d098c 100644 --- a/solr/core/src/java/org/apache/solr/search/facet/FacetRequest.java +++ b/solr/core/src/java/org/apache/solr/search/facet/FacetRequest.java @@ -61,8 +61,7 @@ public FacetSort(final String sortVariable, final SortDirection sortDirection) { @Override public boolean equals(Object other) { - if (other instanceof FacetSort) { - final FacetSort that = (FacetSort) other; + if (other instanceof FacetSort that) { return this.sortVariable.equals(that.sortVariable) && this.sortDirection.equals(that.sortDirection); } diff --git a/solr/core/src/java/org/apache/solr/search/facet/FieldUtil.java b/solr/core/src/java/org/apache/solr/search/facet/FieldUtil.java index 07abc6c6ab1..cdc72532863 100644 --- a/solr/core/src/java/org/apache/solr/search/facet/FieldUtil.java +++ b/solr/core/src/java/org/apache/solr/search/facet/FieldUtil.java @@ -84,9 +84,7 @@ public static boolean isFieldCache(SortedDocValues singleDv) { public static void visitOrds(SortedDocValues singleDv, DocIdSetIterator disi, OrdFunc ordFunc) throws IOException { int doc; - if (singleDv instanceof FieldCacheImpl.SortedDocValuesImpl.Iter) { - FieldCacheImpl.SortedDocValuesImpl.Iter fc = - (FieldCacheImpl.SortedDocValuesImpl.Iter) singleDv; + if (singleDv instanceof FieldCacheImpl.SortedDocValuesImpl.Iter fc) { while ((doc = disi.nextDoc()) != DocIdSetIterator.NO_MORE_DOCS) { ordFunc.handleOrd(doc, fc.getOrd(doc)); } @@ -102,9 +100,7 @@ public static void visitOrds(SortedDocValues singleDv, DocIdSetIterator disi, Or } public static OrdValues getOrdValues(SortedDocValues singleDv, DocIdSetIterator disi) { - if (singleDv instanceof FieldCacheImpl.SortedDocValuesImpl.Iter) { - FieldCacheImpl.SortedDocValuesImpl.Iter fc = - (FieldCacheImpl.SortedDocValuesImpl.Iter) singleDv; + if (singleDv instanceof FieldCacheImpl.SortedDocValuesImpl.Iter fc) { return new FCOrdValues(fc, disi); } return new DVOrdValues(singleDv, disi); diff --git a/solr/core/src/java/org/apache/solr/search/facet/PercentileAgg.java b/solr/core/src/java/org/apache/solr/search/facet/PercentileAgg.java index 1a63f9fa7bf..0d0a842f99e 100644 --- a/solr/core/src/java/org/apache/solr/search/facet/PercentileAgg.java +++ b/solr/core/src/java/org/apache/solr/search/facet/PercentileAgg.java @@ -86,8 +86,7 @@ public FacetMerger createFacetMerger(Object prototype) { @Override public boolean equals(Object o) { - if (!(o instanceof PercentileAgg)) return false; - PercentileAgg other = (PercentileAgg) o; + if (!(o instanceof PercentileAgg other)) return false; return this.arg.equals(other.arg) && this.percentiles.equals(other.percentiles); } diff --git a/solr/core/src/java/org/apache/solr/search/facet/RelatednessAgg.java b/solr/core/src/java/org/apache/solr/search/facet/RelatednessAgg.java index daba3e5ec0e..f55690bbd55 100644 --- a/solr/core/src/java/org/apache/solr/search/facet/RelatednessAgg.java +++ b/solr/core/src/java/org/apache/solr/search/facet/RelatednessAgg.java @@ -118,10 +118,9 @@ public String description() { @Override public boolean equals(Object o) { - if (!(o instanceof RelatednessAgg)) { + if (!(o instanceof RelatednessAgg that)) { return false; } - RelatednessAgg that = (RelatednessAgg) o; return Objects.equals(fgQ, that.fgQ) && Objects.equals(bgQ, that.bgQ) && min_pop == that.min_pop; @@ -571,10 +570,9 @@ public int hashCode() { @Override public boolean equals(Object other) { - if (!(other instanceof BucketData)) { + if (!(other instanceof BucketData that)) { return false; } - BucketData that = (BucketData) other; // we will most certainly be compared to other buckets of the same Agg instance, so compare // counts first return this.implied == that.implied diff --git a/solr/core/src/java/org/apache/solr/search/function/DualDoubleFunction.java b/solr/core/src/java/org/apache/solr/search/function/DualDoubleFunction.java index 718e81d9528..1d2371dbd33 100644 --- a/solr/core/src/java/org/apache/solr/search/function/DualDoubleFunction.java +++ b/solr/core/src/java/org/apache/solr/search/function/DualDoubleFunction.java @@ -98,8 +98,7 @@ public int hashCode() { @Override public boolean equals(Object o) { - if (!(o instanceof DualDoubleFunction)) return false; - DualDoubleFunction other = (DualDoubleFunction) o; + if (!(o instanceof DualDoubleFunction other)) return false; return Objects.equals(this.a, other.a) && Objects.equals(this.b, other.b); } } diff --git a/solr/core/src/java/org/apache/solr/search/function/FileFloatSource.java b/solr/core/src/java/org/apache/solr/search/function/FileFloatSource.java index 7664a822bcb..2d38957912d 100644 --- a/solr/core/src/java/org/apache/solr/search/function/FileFloatSource.java +++ b/solr/core/src/java/org/apache/solr/search/function/FileFloatSource.java @@ -109,8 +109,7 @@ public Object objectVal(int doc) { @Override public boolean equals(Object o) { - if (!(o instanceof FileFloatSource)) return false; - FileFloatSource other = (FileFloatSource) o; + if (!(o instanceof FileFloatSource other)) return false; return this.field.getName().equals(other.field.getName()) && this.keyField.getName().equals(other.keyField.getName()) && this.defVal == other.defVal @@ -242,8 +241,7 @@ public Entry(FileFloatSource ffs) { @Override public boolean equals(Object o) { - if (!(o instanceof Entry)) return false; - Entry other = (Entry) o; + if (!(o instanceof Entry other)) return false; return ffs.equals(other.ffs); } diff --git a/solr/core/src/java/org/apache/solr/search/function/MultiStringFunction.java b/solr/core/src/java/org/apache/solr/search/function/MultiStringFunction.java index 6379beb004c..19744e9da7d 100644 --- a/solr/core/src/java/org/apache/solr/search/function/MultiStringFunction.java +++ b/solr/core/src/java/org/apache/solr/search/function/MultiStringFunction.java @@ -134,8 +134,7 @@ public void fillValue(int doc) throws IOException { @Override public boolean equals(Object o) { - if (!(o instanceof MultiStringFunction)) return false; - MultiStringFunction other = (MultiStringFunction) o; + if (!(o instanceof MultiStringFunction other)) return false; return Objects.equals(this.name(), other.name()) && Arrays.equals(this.sources, other.sources); } diff --git a/solr/core/src/java/org/apache/solr/search/function/OrdFieldSource.java b/solr/core/src/java/org/apache/solr/search/function/OrdFieldSource.java index bbcb81363b5..2442674e096 100644 --- a/solr/core/src/java/org/apache/solr/search/function/OrdFieldSource.java +++ b/solr/core/src/java/org/apache/solr/search/function/OrdFieldSource.java @@ -73,9 +73,7 @@ public FunctionValues getValues(Map context, LeafReaderContext r final int off = readerContext.docBase; final LeafReader r; Object o = context.get("searcher"); - if (o instanceof SolrIndexSearcher) { - @SuppressWarnings("resource") - final SolrIndexSearcher is = (SolrIndexSearcher) o; + if (o instanceof @SuppressWarnings("resource") SolrIndexSearcher is) { SchemaField sf = is.getSchema().getFieldOrNull(field); if (sf != null && sf.getType().isPointField()) { throw new SolrException( diff --git a/solr/core/src/java/org/apache/solr/search/function/ReverseOrdFieldSource.java b/solr/core/src/java/org/apache/solr/search/function/ReverseOrdFieldSource.java index 5e725f79dab..45b343e29da 100644 --- a/solr/core/src/java/org/apache/solr/search/function/ReverseOrdFieldSource.java +++ b/solr/core/src/java/org/apache/solr/search/function/ReverseOrdFieldSource.java @@ -71,9 +71,7 @@ public FunctionValues getValues(Map context, LeafReaderContext r final int off = readerContext.docBase; final LeafReader r; Object o = context.get("searcher"); - if (o instanceof SolrIndexSearcher) { - @SuppressWarnings("resource") - final SolrIndexSearcher is = (SolrIndexSearcher) o; + if (o instanceof @SuppressWarnings("resource") SolrIndexSearcher is) { SchemaField sf = is.getSchema().getFieldOrNull(field); if (sf != null && sf.getType().isPointField()) { throw new SolrException( @@ -122,8 +120,7 @@ public int intVal(int doc) throws IOException { @Override public boolean equals(Object o) { - if (!(o instanceof ReverseOrdFieldSource)) return false; - ReverseOrdFieldSource other = (ReverseOrdFieldSource) o; + if (!(o instanceof ReverseOrdFieldSource other)) return false; return this.field.equals(other.field); } diff --git a/solr/core/src/java/org/apache/solr/search/function/ValueSourceRangeFilter.java b/solr/core/src/java/org/apache/solr/search/function/ValueSourceRangeFilter.java index 457bc756b32..0deb5744e8d 100644 --- a/solr/core/src/java/org/apache/solr/search/function/ValueSourceRangeFilter.java +++ b/solr/core/src/java/org/apache/solr/search/function/ValueSourceRangeFilter.java @@ -147,9 +147,8 @@ public void visit(QueryVisitor visitor) { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof ValueSourceRangeFilter)) return false; + if (!(o instanceof ValueSourceRangeFilter other)) return false; - ValueSourceRangeFilter other = (ValueSourceRangeFilter) o; return Objects.equals(this.valueSource, other.valueSource) && this.includeLower == other.includeLower && this.includeUpper == other.includeUpper diff --git a/solr/core/src/java/org/apache/solr/search/function/distance/GeoDistValueSourceParser.java b/solr/core/src/java/org/apache/solr/search/function/distance/GeoDistValueSourceParser.java index e43f668929e..3db627ea7d1 100644 --- a/solr/core/src/java/org/apache/solr/search/function/distance/GeoDistValueSourceParser.java +++ b/solr/core/src/java/org/apache/solr/search/function/distance/GeoDistValueSourceParser.java @@ -227,8 +227,7 @@ private MultiValueSource getMultiValueSource(FunctionQParser fp, String sfield) throws SyntaxError { SchemaField sf = fp.getReq().getSchema().getField(sfield); FieldType type = sf.getType(); - if (type instanceof AbstractSpatialFieldType) { - AbstractSpatialFieldType asft = (AbstractSpatialFieldType) type; + if (type instanceof AbstractSpatialFieldType asft) { return new SpatialStrategyMultiValueSource(asft.getStrategy(sfield), asft.getDistanceUnits()); } ValueSource vs = type.getValueSource(sf, fp); diff --git a/solr/core/src/java/org/apache/solr/search/function/distance/GeohashFunction.java b/solr/core/src/java/org/apache/solr/search/function/distance/GeohashFunction.java index 06955ac4a67..730b6657186 100644 --- a/solr/core/src/java/org/apache/solr/search/function/distance/GeohashFunction.java +++ b/solr/core/src/java/org/apache/solr/search/function/distance/GeohashFunction.java @@ -70,9 +70,7 @@ public String toString(int doc) throws IOException { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof GeohashFunction)) return false; - - GeohashFunction that = (GeohashFunction) o; + if (!(o instanceof GeohashFunction that)) return false; if (!lat.equals(that.lat)) return false; if (!lon.equals(that.lon)) return false; diff --git a/solr/core/src/java/org/apache/solr/search/function/distance/GeohashHaversineFunction.java b/solr/core/src/java/org/apache/solr/search/function/distance/GeohashHaversineFunction.java index 6ffb4691d8e..7c13ab9d56e 100644 --- a/solr/core/src/java/org/apache/solr/search/function/distance/GeohashHaversineFunction.java +++ b/solr/core/src/java/org/apache/solr/search/function/distance/GeohashHaversineFunction.java @@ -105,8 +105,7 @@ public void createWeight(Map context, IndexSearcher searcher) th @Override public boolean equals(Object o) { - if (!(o instanceof GeohashHaversineFunction)) return false; - GeohashHaversineFunction other = (GeohashHaversineFunction) o; + if (!(o instanceof GeohashHaversineFunction other)) return false; return Objects.equals(this.name(), other.name()) && Objects.equals(geoHash1, other.geoHash1) && Objects.equals(geoHash2, other.geoHash2) diff --git a/solr/core/src/java/org/apache/solr/search/function/distance/HaversineConstFunction.java b/solr/core/src/java/org/apache/solr/search/function/distance/HaversineConstFunction.java index 635f8b9a1ec..fb6500f9a4e 100644 --- a/solr/core/src/java/org/apache/solr/search/function/distance/HaversineConstFunction.java +++ b/solr/core/src/java/org/apache/solr/search/function/distance/HaversineConstFunction.java @@ -99,8 +99,7 @@ public void createWeight(Map context, IndexSearcher searcher) th @Override public boolean equals(Object o) { - if (!(o instanceof HaversineConstFunction)) return false; - HaversineConstFunction other = (HaversineConstFunction) o; + if (!(o instanceof HaversineConstFunction other)) return false; return this.latCenter == other.latCenter && this.lonCenter == other.lonCenter && this.p2.equals(other.p2); diff --git a/solr/core/src/java/org/apache/solr/search/function/distance/HaversineFunction.java b/solr/core/src/java/org/apache/solr/search/function/distance/HaversineFunction.java index 2a0203536f9..6e6a640efb1 100644 --- a/solr/core/src/java/org/apache/solr/search/function/distance/HaversineFunction.java +++ b/solr/core/src/java/org/apache/solr/search/function/distance/HaversineFunction.java @@ -124,8 +124,7 @@ public void createWeight(Map context, IndexSearcher searcher) th @Override public boolean equals(Object o) { - if (!(o instanceof HaversineFunction)) return false; - HaversineFunction other = (HaversineFunction) o; + if (!(o instanceof HaversineFunction other)) return false; return Objects.equals(this.name(), other.name()) && Objects.equals(p1, other.p1) && Objects.equals(p2, other.p2) diff --git a/solr/core/src/java/org/apache/solr/search/function/distance/SquaredEuclideanFunction.java b/solr/core/src/java/org/apache/solr/search/function/distance/SquaredEuclideanFunction.java index 69acf99b62d..42153f5aab7 100644 --- a/solr/core/src/java/org/apache/solr/search/function/distance/SquaredEuclideanFunction.java +++ b/solr/core/src/java/org/apache/solr/search/function/distance/SquaredEuclideanFunction.java @@ -54,11 +54,9 @@ protected double distance(int doc, FunctionValues dv1, FunctionValues dv2) throw @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof SquaredEuclideanFunction)) return false; + if (!(o instanceof SquaredEuclideanFunction that)) return false; if (!super.equals(o)) return false; - SquaredEuclideanFunction that = (SquaredEuclideanFunction) o; - if (!name.equals(that.name)) return false; return true; diff --git a/solr/core/src/java/org/apache/solr/search/function/distance/StringDistanceFunction.java b/solr/core/src/java/org/apache/solr/search/function/distance/StringDistanceFunction.java index 9b47d261c2b..b3c418b8d6a 100644 --- a/solr/core/src/java/org/apache/solr/search/function/distance/StringDistanceFunction.java +++ b/solr/core/src/java/org/apache/solr/search/function/distance/StringDistanceFunction.java @@ -86,9 +86,7 @@ public String description() { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof StringDistanceFunction)) return false; - - StringDistanceFunction that = (StringDistanceFunction) o; + if (!(o instanceof StringDistanceFunction that)) return false; if (!dist.equals(that.dist)) return false; if (!str1.equals(that.str1)) return false; diff --git a/solr/core/src/java/org/apache/solr/search/function/distance/VectorDistanceFunction.java b/solr/core/src/java/org/apache/solr/search/function/distance/VectorDistanceFunction.java index d41479559ee..e5c3d8aea22 100644 --- a/solr/core/src/java/org/apache/solr/search/function/distance/VectorDistanceFunction.java +++ b/solr/core/src/java/org/apache/solr/search/function/distance/VectorDistanceFunction.java @@ -184,9 +184,7 @@ public void createWeight(Map context, IndexSearcher searcher) th @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof VectorDistanceFunction)) return false; - - VectorDistanceFunction that = (VectorDistanceFunction) o; + if (!(o instanceof VectorDistanceFunction that)) return false; if (Float.compare(that.power, power) != 0) return false; if (!source1.equals(that.source1)) return false; diff --git a/solr/core/src/java/org/apache/solr/search/grouping/distributed/shardresultserializer/SearchGroupsResultTransformer.java b/solr/core/src/java/org/apache/solr/search/grouping/distributed/shardresultserializer/SearchGroupsResultTransformer.java index 8ca72d10878..b94863407a9 100644 --- a/solr/core/src/java/org/apache/solr/search/grouping/distributed/shardresultserializer/SearchGroupsResultTransformer.java +++ b/solr/core/src/java/org/apache/solr/search/grouping/distributed/shardresultserializer/SearchGroupsResultTransformer.java @@ -57,8 +57,7 @@ public NamedList> transform(List> data) throws IOEx final NamedList> result = new NamedList<>(data.size()); for (Command command : data) { final NamedList commandResult = new NamedList<>(2); - if (command instanceof SearchGroupsFieldCommand) { - SearchGroupsFieldCommand fieldCommand = (SearchGroupsFieldCommand) command; + if (command instanceof SearchGroupsFieldCommand fieldCommand) { final SearchGroupsFieldCommandResult fieldCommandResult = fieldCommand.result(); final Collection> searchGroups = fieldCommandResult.getSearchGroups(); if (searchGroups != null) { diff --git a/solr/core/src/java/org/apache/solr/search/grouping/distributed/shardresultserializer/TopGroupsResultTransformer.java b/solr/core/src/java/org/apache/solr/search/grouping/distributed/shardresultserializer/TopGroupsResultTransformer.java index 83255675fdd..5a924151fe5 100644 --- a/solr/core/src/java/org/apache/solr/search/grouping/distributed/shardresultserializer/TopGroupsResultTransformer.java +++ b/solr/core/src/java/org/apache/solr/search/grouping/distributed/shardresultserializer/TopGroupsResultTransformer.java @@ -72,12 +72,10 @@ public NamedList> transform(List> data) throws IOEx final IndexSchema schema = rb.req.getSearcher().getSchema(); for (Command command : data) { NamedList commandResult; - if (command instanceof TopGroupsFieldCommand) { - TopGroupsFieldCommand fieldCommand = (TopGroupsFieldCommand) command; + if (command instanceof TopGroupsFieldCommand fieldCommand) { SchemaField groupField = schema.getField(fieldCommand.getKey()); commandResult = serializeTopGroups(fieldCommand.result(), groupField); - } else if (command instanceof QueryCommand) { - QueryCommand queryCommand = (QueryCommand) command; + } else if (command instanceof QueryCommand queryCommand) { commandResult = serializeTopDocs(queryCommand.result()); } else { commandResult = null; @@ -241,11 +239,10 @@ protected NamedList serializeTopGroups(TopGroups data, SchemaF if (!Float.isNaN(searchGroup.scoreDocs[i].score)) { document.add("score", searchGroup.scoreDocs[i].score); } - if (!(searchGroup.scoreDocs[i] instanceof FieldDoc)) { + if (!(searchGroup.scoreDocs[i] instanceof FieldDoc fieldDoc)) { continue; // thus don't add sortValues below } - FieldDoc fieldDoc = (FieldDoc) searchGroup.scoreDocs[i]; Object[] convertedSortValues = new Object[fieldDoc.fields.length]; for (int j = 0; j < fieldDoc.fields.length; j++) { Object sortValue = fieldDoc.fields[j]; @@ -304,11 +301,10 @@ protected NamedList serializeTopDocs(QueryCommandResult result) throws I if (!Float.isNaN(scoreDoc.score)) { document.add("score", scoreDoc.score); } - if (!(scoreDoc instanceof FieldDoc)) { + if (!(scoreDoc instanceof FieldDoc fieldDoc)) { continue; // thus don't add sortValues below } - FieldDoc fieldDoc = (FieldDoc) scoreDoc; Object[] convertedSortValues = new Object[fieldDoc.fields.length]; for (int j = 0; j < fieldDoc.fields.length; j++) { Object sortValue = fieldDoc.fields[j]; diff --git a/solr/core/src/java/org/apache/solr/search/grouping/endresulttransformer/MainEndResultTransformer.java b/solr/core/src/java/org/apache/solr/search/grouping/endresulttransformer/MainEndResultTransformer.java index 1e18b40a21e..94c475237bf 100644 --- a/solr/core/src/java/org/apache/solr/search/grouping/endresulttransformer/MainEndResultTransformer.java +++ b/solr/core/src/java/org/apache/solr/search/grouping/endresulttransformer/MainEndResultTransformer.java @@ -72,8 +72,7 @@ public void transform( docList.setMaxScore(maxScore); } rb.rsp.addResponse(docList); - } else if (value instanceof QueryCommandResult) { - QueryCommandResult queryCommandResult = (QueryCommandResult) value; + } else if (value instanceof QueryCommandResult queryCommandResult) { SolrDocumentList docList = new SolrDocumentList(); TopDocs topDocs = queryCommandResult.getTopDocs(); diff --git a/solr/core/src/java/org/apache/solr/search/grouping/endresulttransformer/SimpleEndResultTransformer.java b/solr/core/src/java/org/apache/solr/search/grouping/endresulttransformer/SimpleEndResultTransformer.java index adfe736dfa8..171ee751f18 100644 --- a/solr/core/src/java/org/apache/solr/search/grouping/endresulttransformer/SimpleEndResultTransformer.java +++ b/solr/core/src/java/org/apache/solr/search/grouping/endresulttransformer/SimpleEndResultTransformer.java @@ -70,8 +70,7 @@ public void transform( } command.add("doclist", docList); commands.add(entry.getKey(), command); - } else if (value instanceof QueryCommandResult) { - QueryCommandResult queryCommandResult = (QueryCommandResult) value; + } else if (value instanceof QueryCommandResult queryCommandResult) { NamedList command = new SimpleOrderedMap<>(); command.add("matches", queryCommandResult.getMatches()); diff --git a/solr/core/src/java/org/apache/solr/search/join/ChildFieldValueSourceParser.java b/solr/core/src/java/org/apache/solr/search/join/ChildFieldValueSourceParser.java index 24d252041ba..720accd090c 100644 --- a/solr/core/src/java/org/apache/solr/search/join/ChildFieldValueSourceParser.java +++ b/solr/core/src/java/org/apache/solr/search/join/ChildFieldValueSourceParser.java @@ -100,8 +100,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { if (this == obj) return true; - if (!(obj instanceof BlockJoinSortFieldValueSource)) return false; - BlockJoinSortFieldValueSource other = (BlockJoinSortFieldValueSource) obj; + if (!(obj instanceof BlockJoinSortFieldValueSource other)) return false; return Objects.equals(childField, other.childField) && Objects.equals(childFilter, other.childFilter) && Objects.equals(parentFilter, other.parentFilter); diff --git a/solr/core/src/java/org/apache/solr/search/join/FiltersQParser.java b/solr/core/src/java/org/apache/solr/search/join/FiltersQParser.java index 0766a8f46d5..05c705aa1ce 100644 --- a/solr/core/src/java/org/apache/solr/search/join/FiltersQParser.java +++ b/solr/core/src/java/org/apache/solr/search/join/FiltersQParser.java @@ -133,8 +133,7 @@ private Collection excludeSet(Map tagMap, Set tagsToExclu // tagMap has entries of List>, but subject to change in the future if (!(olst instanceof Collection)) continue; for (Object o : (Collection) olst) { - if (!(o instanceof QParser)) continue; - QParser qp = (QParser) o; + if (!(o instanceof QParser qp)) continue; excludeSet.put(qp, Boolean.TRUE); } } diff --git a/solr/core/src/java/org/apache/solr/search/join/ScoreJoinQParserPlugin.java b/solr/core/src/java/org/apache/solr/search/join/ScoreJoinQParserPlugin.java index cc227b086b4..d61903440af 100644 --- a/solr/core/src/java/org/apache/solr/search/join/ScoreJoinQParserPlugin.java +++ b/solr/core/src/java/org/apache/solr/search/join/ScoreJoinQParserPlugin.java @@ -154,8 +154,7 @@ public int hashCode() { public boolean equals(Object obj) { if (this == obj) return true; if (!super.equals(obj)) return false; - if (!(obj instanceof OtherCoreJoinQuery)) return false; - OtherCoreJoinQuery other = (OtherCoreJoinQuery) obj; + if (!(obj instanceof OtherCoreJoinQuery other)) return false; return (fromCoreOpenTime == other.fromCoreOpenTime) && Objects.equals(fromIndex, other.fromIndex); } diff --git a/solr/core/src/java/org/apache/solr/search/mlt/AbstractMLTQParser.java b/solr/core/src/java/org/apache/solr/search/mlt/AbstractMLTQParser.java index 356d7583f98..19aded8a79c 100644 --- a/solr/core/src/java/org/apache/solr/search/mlt/AbstractMLTQParser.java +++ b/solr/core/src/java/org/apache/solr/search/mlt/AbstractMLTQParser.java @@ -138,8 +138,7 @@ protected BooleanQuery parseMLTQuery(Supplier fieldsFallback, MLTInvok for (BooleanClause clause : rawMLTQuery) { Query q = clause.getQuery(); float originalBoost = 1f; - if (q instanceof BoostQuery) { - BoostQuery bq = (BoostQuery) q; + if (q instanceof BoostQuery bq) { q = bq.getQuery(); originalBoost = bq.getBoost(); } diff --git a/solr/core/src/java/org/apache/solr/security/BasicAuthPlugin.java b/solr/core/src/java/org/apache/solr/security/BasicAuthPlugin.java index cadc4fed946..07663c92f42 100644 --- a/solr/core/src/java/org/apache/solr/security/BasicAuthPlugin.java +++ b/solr/core/src/java/org/apache/solr/security/BasicAuthPlugin.java @@ -102,8 +102,7 @@ public Map edit(Map latestConf, List readValueAsSet(Map m, String key) { } return null; } - if (val instanceof Collection) { - Collection list = (Collection) val; + if (val instanceof Collection list) { for (Object o : list) result.add(String.valueOf(o)); } else if (val instanceof String) { result.add((String) val); diff --git a/solr/core/src/java/org/apache/solr/security/RuleBasedAuthorizationPluginBase.java b/solr/core/src/java/org/apache/solr/security/RuleBasedAuthorizationPluginBase.java index 7c37e034c73..08321f1bf17 100644 --- a/solr/core/src/java/org/apache/solr/security/RuleBasedAuthorizationPluginBase.java +++ b/solr/core/src/java/org/apache/solr/security/RuleBasedAuthorizationPluginBase.java @@ -216,7 +216,7 @@ private boolean predefinedPermissionAppliesToRequest( if (predefinedPermission.wellknownName == PermissionNameProvider.Name.ALL) { log.trace("'ALL' perm applies to all requests; perm applies."); return true; // 'ALL' applies to everything! - } else if (!(context.getHandler() instanceof PermissionNameProvider)) { + } else if (!(context.getHandler() instanceof PermissionNameProvider handler)) { // TODO: Is this code path needed anymore, now that all handlers implement the interface? // context.getHandler returns Object and is not documented if (log.isTraceEnabled()) { @@ -227,7 +227,6 @@ private boolean predefinedPermissionAppliesToRequest( // We're not 'ALL', and the handler isn't associated with any other predefined permissions return false; } else { - PermissionNameProvider handler = (PermissionNameProvider) context.getHandler(); PermissionNameProvider.Name permissionName = handler.getPermissionName(context); boolean applies = diff --git a/solr/core/src/java/org/apache/solr/servlet/ResponseUtils.java b/solr/core/src/java/org/apache/solr/servlet/ResponseUtils.java index 1f7427f669f..f28b1c2cfea 100644 --- a/solr/core/src/java/org/apache/solr/servlet/ResponseUtils.java +++ b/solr/core/src/java/org/apache/solr/servlet/ResponseUtils.java @@ -68,8 +68,7 @@ public static int getErrorInfo(Throwable ex, NamedList info, Logger log) public static int getErrorInfo( Throwable ex, NamedList info, Logger log, boolean hideTrace) { int code = 500; - if (ex instanceof SolrException) { - SolrException solrExc = (SolrException) ex; + if (ex instanceof SolrException solrExc) { code = solrExc.code(); NamedList errorMetadata = solrExc.getMetadata(); if (errorMetadata == null) { @@ -79,8 +78,7 @@ public static int getErrorInfo( errorMetadata.add( ErrorInfo.ROOT_ERROR_CLASS, SolrException.getRootCause(ex).getClass().getName()); info.add("metadata", errorMetadata); - if (ex instanceof ApiBag.ExceptionWithErrObject) { - ApiBag.ExceptionWithErrObject exception = (ApiBag.ExceptionWithErrObject) ex; + if (ex instanceof ApiBag.ExceptionWithErrObject exception) { info.add("details", exception.getErrs()); } } @@ -142,14 +140,12 @@ public static ErrorInfo getTypedErrorInfo(Throwable ex, Logger log) { public static ErrorInfo getTypedErrorInfo(Throwable ex, Logger log, boolean hideTrace) { final ErrorInfo errorInfo = new ErrorInfo(); int code = 500; - if (ex instanceof SolrException) { - SolrException solrExc = (SolrException) ex; + if (ex instanceof SolrException solrExc) { code = solrExc.code(); errorInfo.metadata = new ErrorInfo.ErrorMetadata(); errorInfo.metadata.errorClass = ex.getClass().getName(); errorInfo.metadata.rootErrorClass = SolrException.getRootCause(ex).getClass().getName(); - if (ex instanceof ApiBag.ExceptionWithErrObject) { - ApiBag.ExceptionWithErrObject exception = (ApiBag.ExceptionWithErrObject) ex; + if (ex instanceof ApiBag.ExceptionWithErrObject exception) { errorInfo.details = exception.getErrs(); } } diff --git a/solr/core/src/java/org/apache/solr/spelling/PossibilityIterator.java b/solr/core/src/java/org/apache/solr/spelling/PossibilityIterator.java index 8f676fa06ea..821df88c4c9 100644 --- a/solr/core/src/java/org/apache/solr/spelling/PossibilityIterator.java +++ b/solr/core/src/java/org/apache/solr/spelling/PossibilityIterator.java @@ -363,8 +363,7 @@ public int hashCode() { public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; - if (!(obj instanceof RankedSpellPossibility)) return false; - RankedSpellPossibility other = (RankedSpellPossibility) obj; + if (!(obj instanceof RankedSpellPossibility other)) return false; return Objects.equals(corrections, other.corrections); } diff --git a/solr/core/src/java/org/apache/solr/spelling/ResultEntry.java b/solr/core/src/java/org/apache/solr/spelling/ResultEntry.java index 67dd64f5f2d..cadb3c76d6e 100644 --- a/solr/core/src/java/org/apache/solr/spelling/ResultEntry.java +++ b/solr/core/src/java/org/apache/solr/spelling/ResultEntry.java @@ -42,8 +42,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { if (this == obj) return true; - if (!(obj instanceof ResultEntry)) return false; - ResultEntry other = (ResultEntry) obj; + if (!(obj instanceof ResultEntry other)) return false; return freq == other.freq && Objects.equals(suggestion, other.suggestion) && Objects.equals(token, other.token); diff --git a/solr/core/src/java/org/apache/solr/spelling/Token.java b/solr/core/src/java/org/apache/solr/spelling/Token.java index c625a9fbdc9..38441722a29 100644 --- a/solr/core/src/java/org/apache/solr/spelling/Token.java +++ b/solr/core/src/java/org/apache/solr/spelling/Token.java @@ -132,9 +132,8 @@ public void clear() { @Override public boolean equals(Object obj) { if (obj == this) return true; - if (!(obj instanceof Token)) return false; + if (!(obj instanceof Token other)) return false; - final Token other = (Token) obj; return (flags == other.flags && (Objects.equals(payload, other.payload)) && super.equals(obj)); } diff --git a/solr/core/src/java/org/apache/solr/uninverting/FieldCacheImpl.java b/solr/core/src/java/org/apache/solr/uninverting/FieldCacheImpl.java index fcaef9b604f..6f23c14a6d7 100644 --- a/solr/core/src/java/org/apache/solr/uninverting/FieldCacheImpl.java +++ b/solr/core/src/java/org/apache/solr/uninverting/FieldCacheImpl.java @@ -225,8 +225,7 @@ static class CacheKey { /** Two of these are equal iff they reference the same field and type. */ @Override public boolean equals(Object o) { - if (o instanceof CacheKey) { - CacheKey other = (CacheKey) o; + if (o instanceof CacheKey other) { if (other.field.equals(field)) { if (other.custom == null) { if (custom == null) return true; diff --git a/solr/core/src/java/org/apache/solr/update/PeerSync.java b/solr/core/src/java/org/apache/solr/update/PeerSync.java index 7636bf54452..1de7cbe3d6a 100644 --- a/solr/core/src/java/org/apache/solr/update/PeerSync.java +++ b/solr/core/src/java/org/apache/solr/update/PeerSync.java @@ -603,11 +603,8 @@ static class Updater { // comparator that sorts update records by absolute value of version, putting lowest first private static final Comparator updateRecordComparator = (o1, o2) -> { - if (!(o1 instanceof List)) return 1; - if (!(o2 instanceof List)) return -1; - - List lst1 = (List) o1; - List lst2 = (List) o2; + if (!(o1 instanceof List lst1)) return 1; + if (!(o2 instanceof List lst2)) return -1; long l1 = Math.abs((Long) lst1.get(1)); long l2 = Math.abs((Long) lst2.get(1)); diff --git a/solr/core/src/java/org/apache/solr/update/SolrCmdDistributor.java b/solr/core/src/java/org/apache/solr/update/SolrCmdDistributor.java index 7f1998d6c82..7683250226f 100644 --- a/solr/core/src/java/org/apache/solr/update/SolrCmdDistributor.java +++ b/solr/core/src/java/org/apache/solr/update/SolrCmdDistributor.java @@ -617,8 +617,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { if (this == obj) return true; - if (!(obj instanceof StdNode)) return false; - StdNode other = (StdNode) obj; + if (!(obj instanceof StdNode other)) return false; return (this.retry == other.retry) && (this.maxRetries == other.maxRetries) && Objects.equals(this.nodeProps.getBaseUrl(), other.nodeProps.getBaseUrl()) @@ -700,8 +699,7 @@ public int hashCode() { public boolean equals(Object obj) { if (this == obj) return true; if (!super.equals(obj)) return false; - if (!(obj instanceof ForwardNode)) return false; - ForwardNode other = (ForwardNode) obj; + if (!(obj instanceof ForwardNode other)) return false; return Objects.equals(nodeProps.getCoreUrl(), other.nodeProps.getCoreUrl()); } } diff --git a/solr/core/src/java/org/apache/solr/update/SolrIndexSplitter.java b/solr/core/src/java/org/apache/solr/update/SolrIndexSplitter.java index fa12d7b51d4..a7267fb298d 100644 --- a/solr/core/src/java/org/apache/solr/update/SolrIndexSplitter.java +++ b/solr/core/src/java/org/apache/solr/update/SolrIndexSplitter.java @@ -633,10 +633,9 @@ public boolean equals(Object obj) { if (this == obj) { return true; } - if (!(obj instanceof SplittingQuery)) { + if (!(obj instanceof SplittingQuery q)) { return false; } - SplittingQuery q = (SplittingQuery) obj; return partition == q.partition; } diff --git a/solr/core/src/java/org/apache/solr/update/TransactionLog.java b/solr/core/src/java/org/apache/solr/update/TransactionLog.java index f8c0d48731d..07b1d0b94fa 100644 --- a/solr/core/src/java/org/apache/solr/update/TransactionLog.java +++ b/solr/core/src/java/org/apache/solr/update/TransactionLog.java @@ -93,8 +93,7 @@ public class TransactionLog implements Closeable { new JavaBinCodec.ObjectResolver() { @Override public Object resolve(Object o, JavaBinCodec codec) throws IOException { - if (o instanceof BytesRef) { - BytesRef br = (BytesRef) o; + if (o instanceof BytesRef br) { codec.writeByteArray(br.bytes, br.offset, br.length); return null; } @@ -161,8 +160,7 @@ protected Object readObject(DataInputInputStream dis) throws IOException { @Override public boolean writePrimitive(Object val) throws IOException { - if (val instanceof java.util.UUID) { - java.util.UUID uuid = (java.util.UUID) val; + if (val instanceof java.util.UUID uuid) { daos.writeByte(UUID); daos.writeLong(uuid.getMostSignificantBits()); daos.writeLong(uuid.getLeastSignificantBits()); diff --git a/solr/core/src/java/org/apache/solr/update/UpdateLog.java b/solr/core/src/java/org/apache/solr/update/UpdateLog.java index d1c430bceee..8e0126073d2 100644 --- a/solr/core/src/java/org/apache/solr/update/UpdateLog.java +++ b/solr/core/src/java/org/apache/solr/update/UpdateLog.java @@ -1215,8 +1215,7 @@ private synchronized List getEntryFromTLog( lookupVersion); } - if (obj != null && obj instanceof List) { - List tmpEntry = (List) obj; + if (obj != null && obj instanceof List tmpEntry) { if (tmpEntry.size() >= 2 && // why not Objects.equals(lookupVersion, tmpEntry.get())? diff --git a/solr/core/src/java/org/apache/solr/update/processor/AddSchemaFieldsUpdateProcessorFactory.java b/solr/core/src/java/org/apache/solr/update/processor/AddSchemaFieldsUpdateProcessorFactory.java index a56361a4652..daea8ce83a4 100644 --- a/solr/core/src/java/org/apache/solr/update/processor/AddSchemaFieldsUpdateProcessorFactory.java +++ b/solr/core/src/java/org/apache/solr/update/processor/AddSchemaFieldsUpdateProcessorFactory.java @@ -191,11 +191,10 @@ private static List parseTypeMappings(NamedList args) { throw new SolrException( SERVER_ERROR, "'" + TYPE_MAPPING_PARAM + "' init param cannot be null"); } - if (!(typeMappingObj instanceof NamedList)) { + if (!(typeMappingObj instanceof NamedList typeMappingNamedList)) { throw new SolrException( SERVER_ERROR, "'" + TYPE_MAPPING_PARAM + "' init param must be a "); } - NamedList typeMappingNamedList = (NamedList) typeMappingObj; Object fieldTypeObj = typeMappingNamedList.remove(FIELD_TYPE_PARAM); if (null == fieldTypeObj) { @@ -256,11 +255,10 @@ private static List parseTypeMappings(NamedList args) { Collection copyFieldDefs = new ArrayList<>(); while (typeMappingNamedList.get(COPY_FIELD_PARAM) != null) { Object copyFieldObj = typeMappingNamedList.remove(COPY_FIELD_PARAM); - if (!(copyFieldObj instanceof NamedList)) { + if (!(copyFieldObj instanceof NamedList copyFieldNamedList)) { throw new SolrException( SERVER_ERROR, "'" + COPY_FIELD_PARAM + "' init param must be a "); } - NamedList copyFieldNamedList = (NamedList) copyFieldObj; // dest Object destObj = copyFieldNamedList.remove(DEST_PARAM); if (null == destObj) { diff --git a/solr/core/src/java/org/apache/solr/update/processor/AtomicUpdateDocumentMerger.java b/solr/core/src/java/org/apache/solr/update/processor/AtomicUpdateDocumentMerger.java index b3544170c68..dbfd33959bd 100644 --- a/solr/core/src/java/org/apache/solr/update/processor/AtomicUpdateDocumentMerger.java +++ b/solr/core/src/java/org/apache/solr/update/processor/AtomicUpdateDocumentMerger.java @@ -587,11 +587,10 @@ protected void doInc(SolrInputDocument toDoc, SolrInputField sif, Object fieldVa // behavior similar to doAdd/doSet Object resObj = getNativeFieldValue(sf.getName(), fieldVal); - if (!(resObj instanceof Number)) { + if (!(resObj instanceof Number result)) { throw new SolrException( ErrorCode.BAD_REQUEST, "Invalid input '" + resObj + "' for field " + sf.getName()); } - Number result = (Number) resObj; if (oldVal instanceof Long) { result = ((Long) oldVal).longValue() + result.longValue(); } else if (oldVal instanceof Float) { @@ -691,10 +690,9 @@ private Object getNativeFieldValue(String fieldName, Object val) { } private static boolean isChildDoc(Object obj) { - if (!(obj instanceof Collection)) { + if (!(obj instanceof Collection objValues)) { return obj instanceof SolrDocumentBase; } - Collection objValues = (Collection) obj; if (objValues.size() == 0) { return false; } diff --git a/solr/core/src/java/org/apache/solr/update/processor/CloneFieldUpdateProcessorFactory.java b/solr/core/src/java/org/apache/solr/update/processor/CloneFieldUpdateProcessorFactory.java index 8f1786a4098..4240454b84d 100644 --- a/solr/core/src/java/org/apache/solr/update/processor/CloneFieldUpdateProcessorFactory.java +++ b/solr/core/src/java/org/apache/solr/update/processor/CloneFieldUpdateProcessorFactory.java @@ -349,11 +349,10 @@ private void initSourceSelectorSyntax(NamedList args) { throw new SolrException( SERVER_ERROR, "Init param '" + SOURCE_PARAM + "' child 'exclude' can not be null"); } - if (!(excObj instanceof NamedList)) { + if (!(excObj instanceof NamedList exc)) { throw new SolrException( SERVER_ERROR, "Init param '" + SOURCE_PARAM + "' child 'exclude' must be "); } - NamedList exc = (NamedList) excObj; srcExclusions.add(parseSelectorParams(exc)); if (0 < exc.size()) { throw new SolrException( @@ -400,8 +399,7 @@ private void initSourceSelectorSyntax(NamedList args) { + "for CloneFieldUpdateProcessorFactory for further details."); } - if (d instanceof NamedList) { - NamedList destList = (NamedList) d; + if (d instanceof NamedList destList) { Object patt = destList.remove(PATTERN_PARAM); Object replacement = destList.remove(REPLACEMENT_PARAM); diff --git a/solr/core/src/java/org/apache/solr/update/processor/DistributedUpdateProcessor.java b/solr/core/src/java/org/apache/solr/update/processor/DistributedUpdateProcessor.java index 8e3153046ad..2edbeb6c345 100644 --- a/solr/core/src/java/org/apache/solr/update/processor/DistributedUpdateProcessor.java +++ b/solr/core/src/java/org/apache/solr/update/processor/DistributedUpdateProcessor.java @@ -1229,8 +1229,7 @@ public DistributedUpdatesAsyncException(List errors) { // create a merged copy of the metadata from all wrapped exceptions NamedList metadata = new NamedList<>(); for (SolrError error : errors) { - if (error.e instanceof SolrException) { - SolrException e = (SolrException) error.e; + if (error.e instanceof SolrException e) { NamedList eMeta = e.getMetadata(); if (null != eMeta) { metadata.addAll(eMeta); diff --git a/solr/core/src/java/org/apache/solr/update/processor/DistributedZkUpdateProcessor.java b/solr/core/src/java/org/apache/solr/update/processor/DistributedZkUpdateProcessor.java index 8c8c3ce6a08..f744be22755 100644 --- a/solr/core/src/java/org/apache/solr/update/processor/DistributedZkUpdateProcessor.java +++ b/solr/core/src/java/org/apache/solr/update/processor/DistributedZkUpdateProcessor.java @@ -680,11 +680,9 @@ private String getLeaderUrlZk(String id) { @Override void setupRequest(UpdateCommand cmd) { zkCheck(cmd); - if (cmd instanceof AddUpdateCommand) { - AddUpdateCommand acmd = (AddUpdateCommand) cmd; + if (cmd instanceof AddUpdateCommand acmd) { nodes = setupRequest(acmd.getIndexedIdStr(), acmd.getSolrInputDocument(), null, cmd); - } else if (cmd instanceof DeleteUpdateCommand) { - DeleteUpdateCommand dcmd = (DeleteUpdateCommand) cmd; + } else if (cmd instanceof DeleteUpdateCommand dcmd) { nodes = setupRequest( dcmd.getId(), @@ -975,8 +973,7 @@ protected List getNodesByRoutingRules( ClusterState cstate, DocCollection coll, String id, SolrInputDocument doc) { DocRouter router = coll.getRouter(); List nodes = null; - if (router instanceof CompositeIdRouter) { - CompositeIdRouter compositeIdRouter = (CompositeIdRouter) router; + if (router instanceof CompositeIdRouter compositeIdRouter) { String myShardId = cloudDesc.getShardId(); Slice slice = coll.getSlice(myShardId); Map routingRules = slice.getRoutingRules(); @@ -1248,8 +1245,7 @@ protected void doDistribFinish() { String collection = null; String shardId = null; - if (error.req.node instanceof SolrCmdDistributor.StdNode) { - SolrCmdDistributor.StdNode stdNode = (SolrCmdDistributor.StdNode) error.req.node; + if (error.req.node instanceof SolrCmdDistributor.StdNode stdNode) { collection = stdNode.getCollection(); shardId = stdNode.getShardId(); diff --git a/solr/core/src/java/org/apache/solr/update/processor/FieldMutatingUpdateProcessorFactory.java b/solr/core/src/java/org/apache/solr/update/processor/FieldMutatingUpdateProcessorFactory.java index 1927cd0b8c9..7571d918a14 100644 --- a/solr/core/src/java/org/apache/solr/update/processor/FieldMutatingUpdateProcessorFactory.java +++ b/solr/core/src/java/org/apache/solr/update/processor/FieldMutatingUpdateProcessorFactory.java @@ -165,11 +165,10 @@ public static Collection parseSelectorExclusionParams(NamedList< throw new SolrException( SolrException.ErrorCode.SERVER_ERROR, "'exclude' init param can not be null"); } - if (!(excObj instanceof NamedList)) { + if (!(excObj instanceof NamedList exc)) { throw new SolrException( SolrException.ErrorCode.SERVER_ERROR, "'exclude' init param must be "); } - NamedList exc = (NamedList) excObj; exclusions.add(parseSelectorParams(exc)); if (0 < exc.size()) { throw new SolrException( diff --git a/solr/core/src/java/org/apache/solr/update/processor/HTMLStripFieldUpdateProcessorFactory.java b/solr/core/src/java/org/apache/solr/update/processor/HTMLStripFieldUpdateProcessorFactory.java index b16466f42a5..a710ccdfe27 100644 --- a/solr/core/src/java/org/apache/solr/update/processor/HTMLStripFieldUpdateProcessorFactory.java +++ b/solr/core/src/java/org/apache/solr/update/processor/HTMLStripFieldUpdateProcessorFactory.java @@ -59,8 +59,7 @@ public UpdateRequestProcessor getInstance( getSelector(), next, src -> { - if (src instanceof CharSequence) { - CharSequence s = (CharSequence) src; + if (src instanceof CharSequence s) { StringWriter result = new StringWriter(s.length()); try (Reader in = new HTMLStripCharFilter(new StringReader(s.toString()))) { in.transferTo(result); diff --git a/solr/core/src/java/org/apache/solr/update/processor/LastFieldValueUpdateProcessorFactory.java b/solr/core/src/java/org/apache/solr/update/processor/LastFieldValueUpdateProcessorFactory.java index 80325f2483e..8be53308a3a 100644 --- a/solr/core/src/java/org/apache/solr/update/processor/LastFieldValueUpdateProcessorFactory.java +++ b/solr/core/src/java/org/apache/solr/update/processor/LastFieldValueUpdateProcessorFactory.java @@ -53,9 +53,8 @@ public Collection pickSubset(Collection values) { T result = null; - if (values instanceof List) { + if (values instanceof List l) { // optimize index lookup - List l = (List) values; result = l.get(l.size() - 1); } else if (values instanceof SortedSet) { // optimize tail lookup diff --git a/solr/core/src/java/org/apache/solr/update/processor/NestedUpdateProcessorFactory.java b/solr/core/src/java/org/apache/solr/update/processor/NestedUpdateProcessorFactory.java index 243890b80fb..96a93b7b45e 100644 --- a/solr/core/src/java/org/apache/solr/update/processor/NestedUpdateProcessorFactory.java +++ b/solr/core/src/java/org/apache/solr/update/processor/NestedUpdateProcessorFactory.java @@ -85,7 +85,7 @@ private boolean processDocChildren(SolrInputDocument doc, String fullPath) { int childNum = 0; boolean isSingleVal = !(field.getValue() instanceof Collection); for (Object val : field) { - if (!(val instanceof SolrInputDocument)) { + if (!(val instanceof SolrInputDocument cDoc)) { // either all collection items are child docs or none are. break; } @@ -101,7 +101,6 @@ private boolean processDocChildren(SolrInputDocument doc, String fullPath) { + "' , which is reserved for the nested URP"); } final String sChildNum = isSingleVal ? SINGULAR_VALUE_CHAR : String.valueOf(childNum); - SolrInputDocument cDoc = (SolrInputDocument) val; if (!cDoc.containsKey(uniqueKeyFieldName)) { String parentDocId = doc.getField(uniqueKeyFieldName).getFirstValue().toString(); cDoc.setField( diff --git a/solr/core/src/java/org/apache/solr/update/processor/RegexReplaceProcessorFactory.java b/solr/core/src/java/org/apache/solr/update/processor/RegexReplaceProcessorFactory.java index 2c9a02dd652..843727bada4 100644 --- a/solr/core/src/java/org/apache/solr/update/processor/RegexReplaceProcessorFactory.java +++ b/solr/core/src/java/org/apache/solr/update/processor/RegexReplaceProcessorFactory.java @@ -120,8 +120,7 @@ public UpdateRequestProcessor getInstance( getSelector(), next, src -> { - if (src instanceof CharSequence) { - CharSequence txt = (CharSequence) src; + if (src instanceof CharSequence txt) { return pattern.matcher(txt).replaceAll(replacement); } return src; diff --git a/solr/core/src/java/org/apache/solr/update/processor/TolerantUpdateProcessor.java b/solr/core/src/java/org/apache/solr/update/processor/TolerantUpdateProcessor.java index 0e2e1a6ca8a..36bfa0fd47e 100644 --- a/solr/core/src/java/org/apache/solr/update/processor/TolerantUpdateProcessor.java +++ b/solr/core/src/java/org/apache/solr/update/processor/TolerantUpdateProcessor.java @@ -238,11 +238,10 @@ public void finish() throws IOException { // // instead we trust the metadata that the TolerantUpdateProcessor running on the remote node // added to the exception when it failed. - if (!(error.e instanceof SolrException)) { + if (!(error.e instanceof SolrException remoteErr)) { log.error("async update exception is not SolrException, no metadata to process", error.e); continue; } - SolrException remoteErr = (SolrException) error.e; NamedList remoteErrMetadata = remoteErr.getMetadata(); if (null == remoteErrMetadata) { diff --git a/solr/core/src/java/org/apache/solr/update/processor/TruncateFieldUpdateProcessorFactory.java b/solr/core/src/java/org/apache/solr/update/processor/TruncateFieldUpdateProcessorFactory.java index 66127f885f7..717f0a54ff7 100644 --- a/solr/core/src/java/org/apache/solr/update/processor/TruncateFieldUpdateProcessorFactory.java +++ b/solr/core/src/java/org/apache/solr/update/processor/TruncateFieldUpdateProcessorFactory.java @@ -89,8 +89,7 @@ public UpdateRequestProcessor getInstance( getSelector(), next, src -> { - if (src instanceof CharSequence) { - CharSequence s = (CharSequence) src; + if (src instanceof CharSequence s) { if (maxLength < s.length()) { return s.subSequence(0, maxLength); } diff --git a/solr/core/src/java/org/apache/solr/update/processor/UpdateRequestProcessorChain.java b/solr/core/src/java/org/apache/solr/update/processor/UpdateRequestProcessorChain.java index 1f5476632f8..f7f5cba5852 100644 --- a/solr/core/src/java/org/apache/solr/update/processor/UpdateRequestProcessorChain.java +++ b/solr/core/src/java/org/apache/solr/update/processor/UpdateRequestProcessorChain.java @@ -348,8 +348,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { - if (!(obj instanceof ProcessorInfo)) return false; - ProcessorInfo that = (ProcessorInfo) obj; + if (!(obj instanceof ProcessorInfo that)) return false; return Objects.equals(this.processor, that.processor) && Objects.equals(this.postProcessor, that.postProcessor); diff --git a/solr/core/src/java/org/apache/solr/util/PayloadUtils.java b/solr/core/src/java/org/apache/solr/util/PayloadUtils.java index ed667de1e40..cda02b4d75c 100644 --- a/solr/core/src/java/org/apache/solr/util/PayloadUtils.java +++ b/solr/core/src/java/org/apache/solr/util/PayloadUtils.java @@ -50,10 +50,9 @@ public static String getPayloadEncoder(FieldType fieldType) { // component that encodes payloads as floats String encoder = null; Analyzer a = fieldType.getIndexAnalyzer(); - if (a instanceof TokenizerChain) { + if (a instanceof TokenizerChain tc) { // examine the indexing analysis chain for DelimitedPayloadTokenFilterFactory or // NumericPayloadTokenFilterFactory - TokenizerChain tc = (TokenizerChain) a; TokenFilterFactory[] factories = tc.getTokenFilterFactories(); for (TokenFilterFactory factory : factories) { if (factory instanceof DelimitedPayloadTokenFilterFactory) { diff --git a/solr/core/src/java/org/apache/solr/util/SolrJacksonAnnotationInspector.java b/solr/core/src/java/org/apache/solr/util/SolrJacksonAnnotationInspector.java index 97af568274c..e7ad4723c79 100644 --- a/solr/core/src/java/org/apache/solr/util/SolrJacksonAnnotationInspector.java +++ b/solr/core/src/java/org/apache/solr/util/SolrJacksonAnnotationInspector.java @@ -52,8 +52,7 @@ public Version version() { @Override public PropertyName findNameForSerialization(Annotated a) { - if (a instanceof AnnotatedMethod) { - AnnotatedMethod am = (AnnotatedMethod) a; + if (a instanceof AnnotatedMethod am) { JsonProperty prop = am.getAnnotation(JsonProperty.class); if (prop == null) return null; if (prop.value().isEmpty()) { @@ -62,8 +61,7 @@ public PropertyName findNameForSerialization(Annotated a) { return new PropertyName(prop.value()); } } - if (a instanceof AnnotatedField) { - AnnotatedField af = (AnnotatedField) a; + if (a instanceof AnnotatedField af) { JsonProperty prop = af.getAnnotation(JsonProperty.class); if (prop == null) return null; return prop.value().isEmpty() diff --git a/solr/core/src/java/org/apache/solr/util/SolrPluginUtils.java b/solr/core/src/java/org/apache/solr/util/SolrPluginUtils.java index 44ade037f0e..d820d699985 100644 --- a/solr/core/src/java/org/apache/solr/util/SolrPluginUtils.java +++ b/solr/core/src/java/org/apache/solr/util/SolrPluginUtils.java @@ -712,8 +712,7 @@ private static void flattenBooleanQuery( Query cq = clause.getQuery(); float boost = fromBoost; - while (cq instanceof BoostQuery) { - BoostQuery bq = (BoostQuery) cq; + while (cq instanceof BoostQuery bq) { cq = bq.getQuery(); boost *= bq.getBoost(); } diff --git a/solr/core/src/java/org/apache/solr/util/circuitbreaker/CPUCircuitBreaker.java b/solr/core/src/java/org/apache/solr/util/circuitbreaker/CPUCircuitBreaker.java index 435ca03ff86..cf226f1e6c0 100644 --- a/solr/core/src/java/org/apache/solr/util/circuitbreaker/CPUCircuitBreaker.java +++ b/solr/core/src/java/org/apache/solr/util/circuitbreaker/CPUCircuitBreaker.java @@ -118,9 +118,7 @@ protected double calculateLiveCPUUsage() { return -1.0; } - if (metric instanceof Gauge) { - @SuppressWarnings({"rawtypes"}) - Gauge gauge = (Gauge) metric; + if (metric instanceof Gauge gauge) { // unwrap if needed if (gauge instanceof SolrMetricManager.GaugeWrapper) { gauge = ((SolrMetricManager.GaugeWrapper) gauge).getGauge(); diff --git a/solr/core/src/java/org/apache/solr/util/stats/InstrumentedHttpRequestExecutor.java b/solr/core/src/java/org/apache/solr/util/stats/InstrumentedHttpRequestExecutor.java index b50751a1ce0..e4be2d9b2fa 100644 --- a/solr/core/src/java/org/apache/solr/util/stats/InstrumentedHttpRequestExecutor.java +++ b/solr/core/src/java/org/apache/solr/util/stats/InstrumentedHttpRequestExecutor.java @@ -49,8 +49,7 @@ public class InstrumentedHttpRequestExecutor extends HttpRequestExecutor try { final RequestLine requestLine = request.getRequestLine(); String schemeHostPort = null; - if (request instanceof HttpRequestWrapper) { - HttpRequestWrapper wrapper = (HttpRequestWrapper) request; + if (request instanceof HttpRequestWrapper wrapper) { if (wrapper.getTarget() != null) { schemeHostPort = wrapper.getTarget().getSchemeName() @@ -80,8 +79,7 @@ public class InstrumentedHttpRequestExecutor extends HttpRequestExecutor try { final RequestLine requestLine = request.getRequestLine(); String schemeHostPort = null; - if (request instanceof HttpRequestWrapper) { - HttpRequestWrapper wrapper = (HttpRequestWrapper) request; + if (request instanceof HttpRequestWrapper wrapper) { if (wrapper.getTarget() != null) { schemeHostPort = wrapper.getTarget().getSchemeName() diff --git a/solr/core/src/java/org/apache/solr/util/stats/MetricUtils.java b/solr/core/src/java/org/apache/solr/util/stats/MetricUtils.java index 71f240ac0a8..9cff065c06f 100644 --- a/solr/core/src/java/org/apache/solr/util/stats/MetricUtils.java +++ b/solr/core/src/java/org/apache/solr/util/stats/MetricUtils.java @@ -192,8 +192,7 @@ static void toSolrInputDocument(String prefix, SolrInputDocument doc, Object o) doc.addField(key, v); } }; - if (o instanceof MapWriter) { - MapWriter writer = (MapWriter) o; + if (o instanceof MapWriter writer) { writer._forEachEntry(consumer); } else if (o instanceof Map) { @SuppressWarnings({"unchecked"}) @@ -201,8 +200,7 @@ static void toSolrInputDocument(String prefix, SolrInputDocument doc, Object o) for (Map.Entry entry : map.entrySet()) { consumer.accept(entry.getKey(), entry.getValue()); } - } else if (o instanceof IteratorWriter) { - IteratorWriter writer = (IteratorWriter) o; + } else if (o instanceof IteratorWriter writer) { final String name = prefix != null ? prefix : "value"; try { writer.writeIter( @@ -348,11 +346,9 @@ public static void convertMetric( boolean simple, String separator, BiConsumer consumer) { - if (metric instanceof Counter) { - Counter counter = (Counter) metric; + if (metric instanceof Counter counter) { convertCounter(n, counter, propertyFilter, compact, consumer); - } else if (metric instanceof Gauge) { - Gauge gauge = (Gauge) metric; + } else if (metric instanceof Gauge gauge) { // unwrap if needed if (gauge instanceof SolrMetricManager.GaugeWrapper) { gauge = ((SolrMetricManager.GaugeWrapper) gauge).getGauge(); @@ -372,11 +368,9 @@ public static void convertMetric( throw ie; } } - } else if (metric instanceof Meter) { - Meter meter = (Meter) metric; + } else if (metric instanceof Meter meter) { convertMeter(n, meter, propertyFilter, simple, separator, consumer); - } else if (metric instanceof Timer) { - Timer timer = (Timer) metric; + } else if (metric instanceof Timer timer) { convertTimer(n, timer, propertyFilter, skipHistograms, simple, separator, consumer); } else if (metric instanceof Histogram) { if (!skipHistograms) { diff --git a/solr/core/src/java/org/apache/solr/util/vector/DenseVectorParser.java b/solr/core/src/java/org/apache/solr/util/vector/DenseVectorParser.java index 29001b3d789..14c4b4ff653 100644 --- a/solr/core/src/java/org/apache/solr/util/vector/DenseVectorParser.java +++ b/solr/core/src/java/org/apache/solr/util/vector/DenseVectorParser.java @@ -51,11 +51,10 @@ protected void parseVector() { } protected void parseIndexVector() { - if (!(inputValue instanceof List)) { + if (!(inputValue instanceof List inputVector)) { throw new SolrException( SolrException.ErrorCode.BAD_REQUEST, "incorrect vector format. " + errorMessage()); } - List inputVector = (List) inputValue; checkVectorDimension(inputVector.size()); if (inputVector.get(0) instanceof CharSequence) { for (int i = 0; i < dimension; i++) { diff --git a/solr/core/src/test/org/apache/solr/TestDistributedSearch.java b/solr/core/src/test/org/apache/solr/TestDistributedSearch.java index 375f0cc479f..5100ea7c38f 100644 --- a/solr/core/src/test/org/apache/solr/TestDistributedSearch.java +++ b/solr/core/src/test/org/apache/solr/TestDistributedSearch.java @@ -1139,8 +1139,7 @@ public void test() throws Exception { "stat should be a Number: " + s + " -> " + svals.get(s).getClass(), svals.get(s) instanceof Number); // some loose assertions since we're iterating over various stats - if (svals.get(s) instanceof Double) { - Double val = (Double) svals.get(s); + if (svals.get(s) instanceof Double val) { assertFalse("stat shouldn't be NaN: " + s, val.isNaN()); assertFalse("stat shouldn't be Inf: " + s, val.isInfinite()); assertNotEquals("stat shouldn't be 0: " + s, 0.0D, val, 0.0); diff --git a/solr/core/src/test/org/apache/solr/TestTrie.java b/solr/core/src/test/org/apache/solr/TestTrie.java index ad1bd21f15a..ff2777960d1 100644 --- a/solr/core/src/test/org/apache/solr/TestTrie.java +++ b/solr/core/src/test/org/apache/solr/TestTrie.java @@ -444,8 +444,7 @@ public void testTrieFacet_PrecisionStep() throws Exception { private void checkPrecisionSteps(String fieldType) { FieldType type = h.getCore().getLatestSchema().getFieldType(fieldType); - if (type instanceof TrieField) { - TrieField field = (TrieField) type; + if (type instanceof TrieField field) { assertTrue(field.getPrecisionStep() > 0 && field.getPrecisionStep() < 64); } } diff --git a/solr/core/src/test/org/apache/solr/cloud/DistribDocExpirationUpdateProcessorTest.java b/solr/core/src/test/org/apache/solr/cloud/DistribDocExpirationUpdateProcessorTest.java index 143f1f4dee8..dfd9aa4dc14 100644 --- a/solr/core/src/test/org/apache/solr/cloud/DistribDocExpirationUpdateProcessorTest.java +++ b/solr/core/src/test/org/apache/solr/cloud/DistribDocExpirationUpdateProcessorTest.java @@ -384,8 +384,7 @@ public String toString() { @Override public boolean equals(Object other) { - if (other instanceof ReplicaData) { - ReplicaData that = (ReplicaData) other; + if (other instanceof ReplicaData that) { return this.shardName.equals(that.shardName) && this.coreName.equals(that.coreName) && (this.indexVersion == that.indexVersion) diff --git a/solr/core/src/test/org/apache/solr/cloud/TestOnReconnectListenerSupport.java b/solr/core/src/test/org/apache/solr/cloud/TestOnReconnectListenerSupport.java index 040fbc5e7eb..e080a4ddc7f 100644 --- a/solr/core/src/test/org/apache/solr/cloud/TestOnReconnectListenerSupport.java +++ b/solr/core/src/test/org/apache/solr/cloud/TestOnReconnectListenerSupport.java @@ -85,8 +85,7 @@ public void test() throws Exception { assertNotNull("ZkController returned null OnReconnect listeners", listeners); ZkIndexSchemaReader expectedListener = null; for (OnReconnect listener : listeners) { - if (listener instanceof ZkIndexSchemaReader) { - ZkIndexSchemaReader reader = (ZkIndexSchemaReader) listener; + if (listener instanceof ZkIndexSchemaReader reader) { if (leaderCoreId.equals(reader.getUniqueCoreId())) { expectedListener = reader; break; @@ -122,8 +121,7 @@ public void test() throws Exception { expectedListener = null; // reset for (OnReconnect listener : listeners) { - if (listener instanceof ZkIndexSchemaReader) { - ZkIndexSchemaReader reader = (ZkIndexSchemaReader) listener; + if (listener instanceof ZkIndexSchemaReader reader) { if (leaderCoreId.equals(reader.getUniqueCoreId())) { fail( "Previous core " @@ -153,8 +151,7 @@ public void test() throws Exception { listeners = zkController.getCurrentOnReconnectListeners(); for (OnReconnect listener : listeners) { - if (listener instanceof ZkIndexSchemaReader) { - ZkIndexSchemaReader reader = (ZkIndexSchemaReader) listener; + if (listener instanceof ZkIndexSchemaReader reader) { if (reloadedLeaderCoreId.equals(reader.getUniqueCoreId())) { fail( "Previous core " diff --git a/solr/core/src/test/org/apache/solr/cloud/api/collections/ShardSplitTest.java b/solr/core/src/test/org/apache/solr/cloud/api/collections/ShardSplitTest.java index 28335c920eb..7e610b2c2da 100644 --- a/solr/core/src/test/org/apache/solr/cloud/api/collections/ShardSplitTest.java +++ b/solr/core/src/test/org/apache/solr/cloud/api/collections/ShardSplitTest.java @@ -1320,8 +1320,7 @@ protected void deleteAndUpdateCount( public static int getHashRangeIdx(DocRouter router, List ranges, String id) { int hash = 0; - if (router instanceof HashBasedRouter) { - HashBasedRouter hashBasedRouter = (HashBasedRouter) router; + if (router instanceof HashBasedRouter hashBasedRouter) { hash = hashBasedRouter.sliceHash(id, null, null, null); } for (int i = 0; i < ranges.size(); i++) { diff --git a/solr/core/src/test/org/apache/solr/core/TestSolrConfigHandler.java b/solr/core/src/test/org/apache/solr/core/TestSolrConfigHandler.java index 9ef6256d991..b34712c2969 100644 --- a/solr/core/src/test/org/apache/solr/core/TestSolrConfigHandler.java +++ b/solr/core/src/test/org/apache/solr/core/TestSolrConfigHandler.java @@ -732,9 +732,7 @@ public static LinkedHashMapWriter testForResponseElement( } Object actual = Utils.getObjectByPath(m, false, jsonPath); - if (expected instanceof ValidatingJsonMap.PredicateWithErrMsg) { - ValidatingJsonMap.PredicateWithErrMsg predicate = - (ValidatingJsonMap.PredicateWithErrMsg) expected; + if (expected instanceof ValidatingJsonMap.PredicateWithErrMsg predicate) { if (predicate.test(actual) == null) { success = true; break; @@ -982,8 +980,7 @@ public void testReqParams() throws Exception { new ValidatingJsonMap.PredicateWithErrMsg<>() { @Override public String test(Object o) { - if (o instanceof Map) { - Map m = (Map) o; + if (o instanceof Map m) { if ("part1_Value".equals(m.get("part1")) && "part2_Value".equals(m.get("part2"))) return null; } diff --git a/solr/core/src/test/org/apache/solr/handler/admin/TestApiFramework.java b/solr/core/src/test/org/apache/solr/handler/admin/TestApiFramework.java index deefc0e4df3..265968b23c8 100644 --- a/solr/core/src/test/org/apache/solr/handler/admin/TestApiFramework.java +++ b/solr/core/src/test/org/apache/solr/handler/admin/TestApiFramework.java @@ -323,8 +323,7 @@ private SolrQueryResponse invoke( } else { api = V2HttpCall.getApiInfo(mockCC.getRequestHandlers(), fullPath, "GET", fullPath, parts); if (api == null) api = new CompositeApi(null); - if (api instanceof CompositeApi) { - CompositeApi compositeApi = (CompositeApi) api; + if (api instanceof CompositeApi compositeApi) { api = V2HttpCall.getApiInfo(reqHandlers, path, "GET", fullPath, parts); compositeApi.add(api); api = compositeApi; diff --git a/solr/core/src/test/org/apache/solr/handler/component/DistributedFacetPivotSmallTest.java b/solr/core/src/test/org/apache/solr/handler/component/DistributedFacetPivotSmallTest.java index 68de31559c4..97253a63518 100644 --- a/solr/core/src/test/org/apache/solr/handler/component/DistributedFacetPivotSmallTest.java +++ b/solr/core/src/test/org/apache/solr/handler/component/DistributedFacetPivotSmallTest.java @@ -2523,8 +2523,7 @@ public ComparablePivotField(String f, Object v, int count, List pivo public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; - if (!(obj instanceof PivotField)) return false; - PivotField other = (PivotField) obj; + if (!(obj instanceof PivotField other)) return false; if (getCount() != other.getCount()) return false; if (getField() == null) { if (other.getField() != null) return false; @@ -2595,8 +2594,7 @@ public int hashCode() { @Override public boolean equals(Object o) { boolean equal = false; - if (o instanceof ArrayList) { - List otherList = (List) o; + if (o instanceof List otherList) { if (size() == otherList.size()) { equal = true; for (Object objectInOtherList : otherList) { diff --git a/solr/core/src/test/org/apache/solr/handler/tagger/TaggerTestCase.java b/solr/core/src/test/org/apache/solr/handler/tagger/TaggerTestCase.java index 7e68744dc85..da0a8d753f9 100644 --- a/solr/core/src/test/org/apache/solr/handler/tagger/TaggerTestCase.java +++ b/solr/core/src/test/org/apache/solr/handler/tagger/TaggerTestCase.java @@ -241,8 +241,7 @@ public String toString() { @Override public boolean equals(Object obj) { - if (!(obj instanceof TestTag)) return false; - TestTag that = (TestTag) obj; + if (!(obj instanceof TestTag that)) return false; return this.startOffset == that.startOffset && this.endOffset == that.endOffset && Objects.equals(this.docName, that.docName); diff --git a/solr/core/src/test/org/apache/solr/request/TestWriterPerf.java b/solr/core/src/test/org/apache/solr/request/TestWriterPerf.java index f8d1942945e..4ba2c17bedf 100644 --- a/solr/core/src/test/org/apache/solr/request/TestWriterPerf.java +++ b/solr/core/src/test/org/apache/solr/request/TestWriterPerf.java @@ -179,8 +179,7 @@ void doPerf(String writerName, SolrQueryRequest req, int encIter, int decIter) t System.gc(); RTimer timer = new RTimer(); for (int i = 0; i < encIter; i++) { - if (w instanceof BinaryQueryResponseWriter) { - BinaryQueryResponseWriter binWriter = (BinaryQueryResponseWriter) w; + if (w instanceof BinaryQueryResponseWriter binWriter) { out = new ByteArrayOutputStream(); binWriter.write(out, req, rsp); out.close(); diff --git a/solr/core/src/test/org/apache/solr/schema/SchemaVersionSpecificBehaviorTest.java b/solr/core/src/test/org/apache/solr/schema/SchemaVersionSpecificBehaviorTest.java index 41d64fb3cb6..1f37e4c9c37 100644 --- a/solr/core/src/test/org/apache/solr/schema/SchemaVersionSpecificBehaviorTest.java +++ b/solr/core/src/test/org/apache/solr/schema/SchemaVersionSpecificBehaviorTest.java @@ -50,8 +50,7 @@ public void testVersionBehavior() throws Exception { field.omitTermFreqAndPositions()); // 1.4: autoGeneratePhraseQueries default changed to false - if (field.getType() instanceof TextField) { - TextField ft = (TextField) field.getType(); + if (field.getType() instanceof TextField ft) { assertEquals( f + " field's autoPhrase is wrong for ver=" + ver, (v < 1.4F), diff --git a/solr/core/src/test/org/apache/solr/search/RankQueryTestPlugin.java b/solr/core/src/test/org/apache/solr/search/RankQueryTestPlugin.java index c82661200b3..674836772f7 100644 --- a/solr/core/src/test/org/apache/solr/search/RankQueryTestPlugin.java +++ b/solr/core/src/test/org/apache/solr/search/RankQueryTestPlugin.java @@ -105,8 +105,7 @@ public int hashCode() { @Override public boolean equals(Object o) { - if (o instanceof TestRankQuery) { - TestRankQuery trq = (TestRankQuery) o; + if (o instanceof TestRankQuery trq) { return (trq.q.equals(q) && trq.collector == collector); } diff --git a/solr/core/src/test/org/apache/solr/search/TestExtendedDismaxParser.java b/solr/core/src/test/org/apache/solr/search/TestExtendedDismaxParser.java index df78f80215e..d6f20f0e49a 100644 --- a/solr/core/src/test/org/apache/solr/search/TestExtendedDismaxParser.java +++ b/solr/core/src/test/org/apache/solr/search/TestExtendedDismaxParser.java @@ -3124,8 +3124,7 @@ private boolean containsClause( Query query, String field, String value, int boost, boolean fuzzy) { float queryBoost = 1f; - if (query instanceof BoostQuery) { - BoostQuery bq = (BoostQuery) query; + if (query instanceof BoostQuery bq) { query = bq.getQuery(); queryBoost = bq.getBoost(); } diff --git a/solr/core/src/test/org/apache/solr/search/mlt/CloudMLTQContentParserTest.java b/solr/core/src/test/org/apache/solr/search/mlt/CloudMLTQContentParserTest.java index ec8dcae907e..326ca7aaff0 100644 --- a/solr/core/src/test/org/apache/solr/search/mlt/CloudMLTQContentParserTest.java +++ b/solr/core/src/test/org/apache/solr/search/mlt/CloudMLTQContentParserTest.java @@ -177,8 +177,7 @@ public void testMinDF() throws Exception { new String[] {"lowerfilt_u:bmw lowerfilt_u:usa", "lowerfilt_u:usa lowerfilt_u:bmw"}; String[] actualParsedQueries; - if (queryResponse.getDebugMap().get("parsedquery") instanceof String) { - String parsedQueryString = (String) queryResponse.getDebugMap().get("parsedquery"); + if (queryResponse.getDebugMap().get("parsedquery") instanceof String parsedQueryString) { assertTrue( parsedQueryString.equals(expectedQueryStrings[0]) || parsedQueryString.equals(expectedQueryStrings[1])); diff --git a/solr/core/src/test/org/apache/solr/search/mlt/CloudMLTQParserTest.java b/solr/core/src/test/org/apache/solr/search/mlt/CloudMLTQParserTest.java index 5912465f883..0ccf8862969 100644 --- a/solr/core/src/test/org/apache/solr/search/mlt/CloudMLTQParserTest.java +++ b/solr/core/src/test/org/apache/solr/search/mlt/CloudMLTQParserTest.java @@ -239,8 +239,7 @@ public void testMinDF() throws Exception { }; String[] actualParsedQueries; - if (queryResponse.getDebugMap().get("parsedquery") instanceof String) { - String parsedQueryString = (String) queryResponse.getDebugMap().get("parsedquery"); + if (queryResponse.getDebugMap().get("parsedquery") instanceof String parsedQueryString) { assertTrue( parsedQueryString.equals(expectedQueryStrings[0]) || parsedQueryString.equals(expectedQueryStrings[1])); diff --git a/solr/core/src/test/org/apache/solr/security/PrincipalWithUserRoles.java b/solr/core/src/test/org/apache/solr/security/PrincipalWithUserRoles.java index b07b8e5cee3..987b0a4deb6 100644 --- a/solr/core/src/test/org/apache/solr/security/PrincipalWithUserRoles.java +++ b/solr/core/src/test/org/apache/solr/security/PrincipalWithUserRoles.java @@ -65,9 +65,8 @@ public Set getVerifiedRoles() { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof PrincipalWithUserRoles)) return false; + if (!(o instanceof PrincipalWithUserRoles that)) return false; - PrincipalWithUserRoles that = (PrincipalWithUserRoles) o; if (!username.equals(that.username)) return false; return roles.equals(that.roles); } diff --git a/solr/core/src/test/org/apache/solr/update/TestInPlaceUpdatesStandalone.java b/solr/core/src/test/org/apache/solr/update/TestInPlaceUpdatesStandalone.java index 6c26ff47a88..42d3d41c121 100644 --- a/solr/core/src/test/org/apache/solr/update/TestInPlaceUpdatesStandalone.java +++ b/solr/core/src/test/org/apache/solr/update/TestInPlaceUpdatesStandalone.java @@ -1256,10 +1256,9 @@ public void checkReplay(final String valField, Object... commands) throws Except final long version = addAndGetVersion(sdoc, null); final Object val = sdoc.getFieldValue(valField); - if (val instanceof Map) { + if (val instanceof Map atomicUpdate) { // atomic update of the field we're modeling - Map atomicUpdate = (Map) val; assertEquals(sdoc.toString(), 1, atomicUpdate.size()); if (atomicUpdate.containsKey("inc")) { // Solr treats inc on a non-existing doc (or doc w/o existing value) as if existing diff --git a/solr/cross-dc-manager/src/java/org/apache/solr/crossdc/manager/messageprocessor/SolrMessageProcessor.java b/solr/cross-dc-manager/src/java/org/apache/solr/crossdc/manager/messageprocessor/SolrMessageProcessor.java index b4e14feea78..2f4e090bab4 100644 --- a/solr/cross-dc-manager/src/java/org/apache/solr/crossdc/manager/messageprocessor/SolrMessageProcessor.java +++ b/solr/cross-dc-manager/src/java/org/apache/solr/crossdc/manager/messageprocessor/SolrMessageProcessor.java @@ -254,9 +254,8 @@ private void logRequest(SolrRequest request) { * @param request The SolrRequest to be cleaned up for submitting locally. */ private void prepareIfUpdateRequest(SolrRequest request) { - if (request instanceof UpdateRequest) { + if (request instanceof UpdateRequest updateRequest) { // Remove versions from add requests - UpdateRequest updateRequest = (UpdateRequest) request; List documents = updateRequest.getDocuments(); if (log.isTraceEnabled()) { @@ -318,8 +317,7 @@ private void logFirstAttemptLatency(MirroredSolrRequest mirroredSolrRequest) * @param mirroredSolrRequest MirroredSolrRequest object that is being processed. */ void preventCircularMirroring(MirroredSolrRequest mirroredSolrRequest) { - if (mirroredSolrRequest.getSolrRequest() instanceof UpdateRequest) { - UpdateRequest updateRequest = (UpdateRequest) mirroredSolrRequest.getSolrRequest(); + if (mirroredSolrRequest.getSolrRequest() instanceof UpdateRequest updateRequest) { ModifiableSolrParams params = updateRequest.getParams(); String shouldMirror = (params == null ? null : params.get(CrossDcConstants.SHOULD_MIRROR)); if (shouldMirror == null) { diff --git a/solr/modules/analysis-extras/src/java/org/apache/solr/update/processor/OpenNLPExtractNamedEntitiesUpdateProcessorFactory.java b/solr/modules/analysis-extras/src/java/org/apache/solr/update/processor/OpenNLPExtractNamedEntitiesUpdateProcessorFactory.java index 9df258cd303..338eeea0e5e 100644 --- a/solr/modules/analysis-extras/src/java/org/apache/solr/update/processor/OpenNLPExtractNamedEntitiesUpdateProcessorFactory.java +++ b/solr/modules/analysis-extras/src/java/org/apache/solr/update/processor/OpenNLPExtractNamedEntitiesUpdateProcessorFactory.java @@ -394,11 +394,10 @@ private void initSourceSelectorSyntax(NamedList args) { throw new SolrException( SERVER_ERROR, "Init param '" + SOURCE_PARAM + "' child 'exclude' can not be null"); } - if (!(excObj instanceof NamedList)) { + if (!(excObj instanceof NamedList exc)) { throw new SolrException( SERVER_ERROR, "Init param '" + SOURCE_PARAM + "' child 'exclude' must be "); } - NamedList exc = (NamedList) excObj; srcExclusions.add(parseSelectorParams(exc)); if (0 < exc.size()) { throw new SolrException( @@ -445,8 +444,7 @@ private void initSourceSelectorSyntax(NamedList args) { + "for OpenNLPExtractNamedEntitiesUpdateProcessor for further details."); } - if (d instanceof NamedList) { - NamedList destList = (NamedList) d; + if (d instanceof NamedList destList) { Object patt = destList.remove(PATTERN_PARAM); Object replacement = destList.remove(REPLACEMENT_PARAM); diff --git a/solr/modules/cross-dc/src/java/org/apache/solr/crossdc/common/MirroredSolrRequest.java b/solr/modules/cross-dc/src/java/org/apache/solr/crossdc/common/MirroredSolrRequest.java index 125c8a46a10..53e2351cf47 100644 --- a/solr/modules/cross-dc/src/java/org/apache/solr/crossdc/common/MirroredSolrRequest.java +++ b/solr/modules/cross-dc/src/java/org/apache/solr/crossdc/common/MirroredSolrRequest.java @@ -267,8 +267,7 @@ public String toString() { sb.append(type.toString()); sb.append(", method=" + solrRequest.getMethod()); sb.append(", params=" + solrRequest.getParams()); - if (solrRequest instanceof UpdateRequest) { - UpdateRequest req = (UpdateRequest) solrRequest; + if (solrRequest instanceof UpdateRequest req) { sb.append(", add=" + (req.getDocuments() != null ? req.getDocuments().size() : "0")); sb.append(", del=" + (req.getDeleteByIdMap() != null ? req.getDeleteByIdMap().size() : "0")); sb.append(", dbq=" + (req.getDeleteQuery() != null ? req.getDeleteQuery().size() : "0")); diff --git a/solr/modules/cross-dc/src/java/org/apache/solr/crossdc/common/MirroredSolrRequestSerializer.java b/solr/modules/cross-dc/src/java/org/apache/solr/crossdc/common/MirroredSolrRequestSerializer.java index f661a2689e8..667b94ba5b5 100644 --- a/solr/modules/cross-dc/src/java/org/apache/solr/crossdc/common/MirroredSolrRequestSerializer.java +++ b/solr/modules/cross-dc/src/java/org/apache/solr/crossdc/common/MirroredSolrRequestSerializer.java @@ -184,14 +184,11 @@ public byte[] serialize(String topic, MirroredSolrRequest request) { map.put("submitTimeNanos", request.getSubmitTimeNanos()); map.put("params", solrRequest.getParams()); map.put("type", request.getType().toString()); - if (solrRequest instanceof UpdateRequest) { - UpdateRequest update = (UpdateRequest) solrRequest; + if (solrRequest instanceof UpdateRequest update) { map.put("docs", update.getDocuments()); map.put("deletes", update.getDeleteById()); map.put("deleteQuery", update.getDeleteQuery()); - } else if (solrRequest instanceof MirroredSolrRequest.MirroredConfigSetRequest) { - MirroredSolrRequest.MirroredConfigSetRequest config = - (MirroredSolrRequest.MirroredConfigSetRequest) solrRequest; + } else if (solrRequest instanceof MirroredSolrRequest.MirroredConfigSetRequest config) { map.put("method", config.getMethod().toString()); if (config.getContentStreams() != null) { List> streamsList = new ArrayList<>(); diff --git a/solr/modules/extraction/src/java/org/apache/solr/handler/extraction/XLSXResponseWriter.java b/solr/modules/extraction/src/java/org/apache/solr/handler/extraction/XLSXResponseWriter.java index d68a86351ab..60a995b4d5d 100644 --- a/solr/modules/extraction/src/java/org/apache/solr/handler/extraction/XLSXResponseWriter.java +++ b/solr/modules/extraction/src/java/org/apache/solr/handler/extraction/XLSXResponseWriter.java @@ -264,8 +264,7 @@ public void writeSolrDocument(String name, SolrDocument doc, ReturnFields return } else { // normalize to first value - if (val instanceof Collection) { - Collection values = (Collection) val; + if (val instanceof Collection values) { val = values.iterator().next(); } writeVal(xlField.name, val); @@ -285,8 +284,7 @@ public void writeArray(String name, Iterator val, boolean raw) throws IOExcep StringBuilder output = new StringBuilder(); while (val.hasNext()) { Object v = val.next(); - if (v instanceof IndexableField) { - IndexableField f = (IndexableField) v; + if (v instanceof IndexableField f) { if (v instanceof Date) { output.append(((Date) val).toInstant().toString()).append("; "); } else { diff --git a/solr/modules/hadoop-auth/src/java/org/apache/solr/security/hadoop/KerberosFilter.java b/solr/modules/hadoop-auth/src/java/org/apache/solr/security/hadoop/KerberosFilter.java index 436342bd484..89dd5bdabe4 100644 --- a/solr/modules/hadoop-auth/src/java/org/apache/solr/security/hadoop/KerberosFilter.java +++ b/solr/modules/hadoop-auth/src/java/org/apache/solr/security/hadoop/KerberosFilter.java @@ -83,8 +83,7 @@ protected void doFilter( private HttpServletRequest substituteOriginalUserRequest(HttpServletRequest request) { final HttpServletRequest originalRequest = request; AuthorizationPlugin authzPlugin = coreContainer.getAuthorizationPlugin(); - if (authzPlugin instanceof RuleBasedAuthorizationPlugin) { - RuleBasedAuthorizationPlugin ruleBased = (RuleBasedAuthorizationPlugin) authzPlugin; + if (authzPlugin instanceof RuleBasedAuthorizationPlugin ruleBased) { if (request.getHeader(KerberosPlugin.ORIGINAL_USER_PRINCIPAL_HEADER) != null && ruleBased.doesUserHavePermission( request.getUserPrincipal(), PermissionNameProvider.Name.ALL)) { diff --git a/solr/modules/hdfs/src/java/org/apache/solr/hdfs/store/HdfsLockFactory.java b/solr/modules/hdfs/src/java/org/apache/solr/hdfs/store/HdfsLockFactory.java index e461c6de8f7..06e43b7dd2d 100644 --- a/solr/modules/hdfs/src/java/org/apache/solr/hdfs/store/HdfsLockFactory.java +++ b/solr/modules/hdfs/src/java/org/apache/solr/hdfs/store/HdfsLockFactory.java @@ -42,11 +42,10 @@ private HdfsLockFactory() {} @Override public Lock obtainLock(Directory dir, String lockName) throws IOException { - if (!(dir instanceof HdfsDirectory)) { + if (!(dir instanceof HdfsDirectory hdfsDir)) { throw new UnsupportedOperationException( "HdfsLockFactory can only be used with HdfsDirectory subclasses, got: " + dir); } - final HdfsDirectory hdfsDir = (HdfsDirectory) dir; final Configuration conf = hdfsDir.getConfiguration(); final Path lockPath = hdfsDir.getHdfsDirPath(); final Path lockFile = new Path(lockPath, lockName); diff --git a/solr/modules/hdfs/src/java/org/apache/solr/hdfs/store/blockcache/BlockCacheKey.java b/solr/modules/hdfs/src/java/org/apache/solr/hdfs/store/blockcache/BlockCacheKey.java index ed02ee53deb..be6e2daa4ee 100644 --- a/solr/modules/hdfs/src/java/org/apache/solr/hdfs/store/blockcache/BlockCacheKey.java +++ b/solr/modules/hdfs/src/java/org/apache/solr/hdfs/store/blockcache/BlockCacheKey.java @@ -64,8 +64,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { if (this == obj) return true; - if (!(obj instanceof BlockCacheKey)) return false; - BlockCacheKey other = (BlockCacheKey) obj; + if (!(obj instanceof BlockCacheKey other)) return false; return block == other.block && file == other.file && Objects.equals(path, other.path); } diff --git a/solr/modules/jwt-auth/src/java/org/apache/solr/security/jwt/JWTAuthPlugin.java b/solr/modules/jwt-auth/src/java/org/apache/solr/security/jwt/JWTAuthPlugin.java index bb64f458f4e..5b9cdd42820 100644 --- a/solr/modules/jwt-auth/src/java/org/apache/solr/security/jwt/JWTAuthPlugin.java +++ b/solr/modules/jwt-auth/src/java/org/apache/solr/security/jwt/JWTAuthPlugin.java @@ -956,10 +956,8 @@ AuthCode getAuthCode() { @Override protected boolean interceptInternodeRequest(HttpRequest httpRequest, HttpContext httpContext) { - if (httpContext instanceof HttpClientContext) { - HttpClientContext httpClientContext = (HttpClientContext) httpContext; - if (httpClientContext.getUserToken() instanceof JWTPrincipal) { - JWTPrincipal jwtPrincipal = (JWTPrincipal) httpClientContext.getUserToken(); + if (httpContext instanceof HttpClientContext httpClientContext) { + if (httpClientContext.getUserToken() instanceof JWTPrincipal jwtPrincipal) { httpRequest.setHeader(HttpHeaders.AUTHORIZATION, "Bearer " + jwtPrincipal.getToken()); return true; } @@ -970,8 +968,7 @@ protected boolean interceptInternodeRequest(HttpRequest httpRequest, HttpContext @Override protected boolean interceptInternodeRequest(Request request) { Object userToken = request.getAttributes().get(Http2SolrClient.REQ_PRINCIPAL_KEY); - if (userToken instanceof JWTPrincipal) { - JWTPrincipal jwtPrincipal = (JWTPrincipal) userToken; + if (userToken instanceof JWTPrincipal jwtPrincipal) { request.headers(h -> h.put(HttpHeaders.AUTHORIZATION, "Bearer " + jwtPrincipal.getToken())); return true; } diff --git a/solr/modules/jwt-auth/src/java/org/apache/solr/security/jwt/JWTPrincipal.java b/solr/modules/jwt-auth/src/java/org/apache/solr/security/jwt/JWTPrincipal.java index 93d2764e83f..e7c26d98f58 100644 --- a/solr/modules/jwt-auth/src/java/org/apache/solr/security/jwt/JWTPrincipal.java +++ b/solr/modules/jwt-auth/src/java/org/apache/solr/security/jwt/JWTPrincipal.java @@ -62,8 +62,7 @@ public Map getClaims() { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof JWTPrincipal)) return false; - JWTPrincipal that = (JWTPrincipal) o; + if (!(o instanceof JWTPrincipal that)) return false; return Objects.equals(username, that.username) && Objects.equals(token, that.token) && Objects.equals(claims, that.claims); diff --git a/solr/modules/jwt-auth/src/java/org/apache/solr/security/jwt/JWTPrincipalWithUserRoles.java b/solr/modules/jwt-auth/src/java/org/apache/solr/security/jwt/JWTPrincipalWithUserRoles.java index 1f298a18ab3..03d870c4e82 100644 --- a/solr/modules/jwt-auth/src/java/org/apache/solr/security/jwt/JWTPrincipalWithUserRoles.java +++ b/solr/modules/jwt-auth/src/java/org/apache/solr/security/jwt/JWTPrincipalWithUserRoles.java @@ -48,8 +48,7 @@ public Set getVerifiedRoles() { @Override public boolean equals(Object o) { - if (!(o instanceof JWTPrincipalWithUserRoles)) return false; - JWTPrincipalWithUserRoles that = (JWTPrincipalWithUserRoles) o; + if (!(o instanceof JWTPrincipalWithUserRoles that)) return false; return super.equals(o) && roles.equals(that.roles); } diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/LTRScoringModel.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/LTRScoringModel.java index 8af64bbec5b..21cca228858 100644 --- a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/LTRScoringModel.java +++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/LTRScoringModel.java @@ -215,8 +215,7 @@ private final int calculateHashCode() { @Override public boolean equals(Object obj) { if (this == obj) return true; - if (!(obj instanceof LTRScoringModel)) return false; - final LTRScoringModel other = (LTRScoringModel) obj; + if (!(obj instanceof LTRScoringModel other)) return false; return Objects.equals(features, other.features) && Objects.equals(norms, other.norms) && Objects.equals(name, other.name) diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/WrapperModel.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/WrapperModel.java index 86eb8c45564..95aef5006f2 100644 --- a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/WrapperModel.java +++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/WrapperModel.java @@ -69,8 +69,7 @@ public int hashCode() { public boolean equals(Object obj) { if (this == obj) return true; if (!super.equals(obj)) return false; - if (!(obj instanceof WrapperModel)) return false; - WrapperModel other = (WrapperModel) obj; + if (!(obj instanceof WrapperModel other)) return false; return Objects.equals(model, other.model) && Objects.equals(solrResourceLoader, other.solrResourceLoader); } diff --git a/solr/modules/s3-repository/src/java/org/apache/solr/s3/S3StorageClient.java b/solr/modules/s3-repository/src/java/org/apache/solr/s3/S3StorageClient.java index 3d600899647..527a951e71e 100644 --- a/solr/modules/s3-repository/src/java/org/apache/solr/s3/S3StorageClient.java +++ b/solr/modules/s3-repository/src/java/org/apache/solr/s3/S3StorageClient.java @@ -582,8 +582,7 @@ String sanitizedDirPath(String path) throws S3Exception { */ static S3Exception handleAmazonException(SdkException sdke) { - if (sdke instanceof AwsServiceException) { - AwsServiceException ase = (AwsServiceException) sdke; + if (sdke instanceof AwsServiceException ase) { String errMessage = String.format( Locale.ROOT, diff --git a/solr/modules/sql/src/java/org/apache/solr/handler/sql/CalciteJDBCStream.java b/solr/modules/sql/src/java/org/apache/solr/handler/sql/CalciteJDBCStream.java index c53e4a25c7b..e2adac35ded 100644 --- a/solr/modules/sql/src/java/org/apache/solr/handler/sql/CalciteJDBCStream.java +++ b/solr/modules/sql/src/java/org/apache/solr/handler/sql/CalciteJDBCStream.java @@ -62,8 +62,7 @@ public Object selectValue(ResultSet resultSet) throws SQLException { if (resultSet.wasNull()) { return null; } - if (o instanceof Array) { - Array array = (Array) o; + if (o instanceof Array array) { return array.getArray(); } else { return o; diff --git a/solr/modules/sql/src/java/org/apache/solr/handler/sql/SolrFilter.java b/solr/modules/sql/src/java/org/apache/solr/handler/sql/SolrFilter.java index c1a15aad586..e29c8ef805d 100644 --- a/solr/modules/sql/src/java/org/apache/solr/handler/sql/SolrFilter.java +++ b/solr/modules/sql/src/java/org/apache/solr/handler/sql/SolrFilter.java @@ -263,10 +263,9 @@ private int compareRexLiteral(final RexLiteral gte, final RexLiteral lte) { } protected String translateIsNullOrIsNotNull(RexNode node) { - if (!(node instanceof RexCall)) { + if (!(node instanceof RexCall call)) { throw new AssertionError("expected RexCall for predicate but found: " + node); } - RexCall call = (RexCall) node; List operands = call.getOperands(); if (operands.size() != 1) { throw new AssertionError("expected 1 operand for " + node); @@ -531,10 +530,9 @@ private String toSolrTimestamp(final String ts) { protected Pair, Character> getFieldValuePairWithEscapeCharacter( RexNode node) { - if (!(node instanceof RexCall)) { + if (!(node instanceof RexCall call)) { throw new AssertionError("expected RexCall for predicate but found: " + node); } - RexCall call = (RexCall) node; if (call.getOperands().size() == 3) { RexNode escapeNode = call.getOperands().get(2); Character escapeChar = null; @@ -552,11 +550,10 @@ protected Pair, Character> getFieldValuePairWithEscapeC } protected Pair getFieldValuePair(RexNode node) { - if (!(node instanceof RexCall)) { + if (!(node instanceof RexCall call)) { throw new AssertionError("expected RexCall for predicate but found: " + node); } - RexCall call = (RexCall) node; Pair binaryTranslated = call.getOperands().size() == 2 ? translateBinary(call) : null; if (binaryTranslated == null) { @@ -654,15 +651,13 @@ protected String translateSearch(RexNode condition) { !expanded.getOperands().isEmpty() ? expanded.getOperands().get(0) : null; if (expanded.op.kind == SqlKind.AND) { // See if NOT IN was translated into a big AND not - if (peekAt0 instanceof RexCall) { - RexCall op0 = (RexCall) peekAt0; + if (peekAt0 instanceof RexCall op0) { if (op0.op.kind == SqlKind.NOT_EQUALS) { return "*:* -" + fieldName + ":" + toOrSetOnSameField(fieldName, expanded); } } } else if (expanded.op.kind == SqlKind.OR) { - if (peekAt0 instanceof RexCall) { - RexCall op0 = (RexCall) peekAt0; + if (peekAt0 instanceof RexCall op0) { if (op0.op.kind == SqlKind.EQUALS) { return fieldName + ":" + toOrSetOnSameField(fieldName, expanded); } diff --git a/solr/prometheus-exporter/src/java/org/apache/solr/prometheus/exporter/MetricsQueryTemplate.java b/solr/prometheus-exporter/src/java/org/apache/solr/prometheus/exporter/MetricsQueryTemplate.java index 48d02ca3a3a..7d0e28ce001 100644 --- a/solr/prometheus-exporter/src/java/org/apache/solr/prometheus/exporter/MetricsQueryTemplate.java +++ b/solr/prometheus-exporter/src/java/org/apache/solr/prometheus/exporter/MetricsQueryTemplate.java @@ -116,8 +116,7 @@ public String applyTemplate(final Matcher matched) { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof MetricsQueryTemplate)) return false; - MetricsQueryTemplate that = (MetricsQueryTemplate) o; + if (!(o instanceof MetricsQueryTemplate that)) return false; return name.equals(that.name) && Objects.equals(defaultType, that.defaultType) && template.equals(that.template); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/comp/FieldComparator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/comp/FieldComparator.java index 5a67c581962..57f4f5da259 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/comp/FieldComparator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/comp/FieldComparator.java @@ -162,14 +162,12 @@ public boolean isDerivedFrom(StreamComparator base) { if (null == base) { return false; } - if (base instanceof FieldComparator) { - FieldComparator baseComp = (FieldComparator) base; + if (base instanceof FieldComparator baseComp) { return (leftFieldName.equals(baseComp.leftFieldName) || rightFieldName.equals(baseComp.rightFieldName)) && order == baseComp.order; - } else if (base instanceof MultipleFieldComparator) { + } else if (base instanceof MultipleFieldComparator baseComps) { // must equal the first one - MultipleFieldComparator baseComps = (MultipleFieldComparator) base; if (baseComps.getComps().length > 0) { return isDerivedFrom(baseComps.getComps()[0]); } @@ -194,8 +192,7 @@ public StreamComparator append(StreamComparator other) { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof FieldComparator)) return false; - FieldComparator that = (FieldComparator) o; + if (!(o instanceof FieldComparator that)) return false; // comparator is based on the other fields so is not needed in this compare return leftFieldName.equals(that.leftFieldName) && rightFieldName.equals(that.rightFieldName) diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/comp/HashKey.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/comp/HashKey.java index a4766ebf477..6dff1948b5c 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/comp/HashKey.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/comp/HashKey.java @@ -48,8 +48,7 @@ public int hashCode() { @Override public boolean equals(Object o) { - if (!(o instanceof HashKey)) return false; - HashKey h = (HashKey) o; + if (!(o instanceof HashKey h)) return false; for (int i = 0; i < parts.length; i++) { if (!parts[i].equals(h.parts[i])) { return false; diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/comp/MultipleFieldComparator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/comp/MultipleFieldComparator.java index 065eabfd68c..6f4b5e86b6a 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/comp/MultipleFieldComparator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/comp/MultipleFieldComparator.java @@ -60,8 +60,7 @@ public int compare(Tuple t1, Tuple t2) { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof MultipleFieldComparator)) return false; - MultipleFieldComparator that = (MultipleFieldComparator) o; + if (!(o instanceof MultipleFieldComparator that)) return false; return Arrays.equals(comps, that.comps); } @@ -93,8 +92,7 @@ public boolean isDerivedFrom(StreamComparator base) { if (null == base) { return false; } - if (base instanceof MultipleFieldComparator) { - MultipleFieldComparator baseComp = (MultipleFieldComparator) base; + if (base instanceof MultipleFieldComparator baseComp) { if (baseComp.comps.length >= comps.length) { for (int idx = 0; idx < comps.length; ++idx) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eq/FieldEqualitor.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eq/FieldEqualitor.java index 95dcb5bebfd..f17b62afc9a 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eq/FieldEqualitor.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eq/FieldEqualitor.java @@ -107,13 +107,11 @@ public boolean isDerivedFrom(StreamEqualitor base) { if (null == base) { return false; } - if (base instanceof FieldEqualitor) { - FieldEqualitor baseEq = (FieldEqualitor) base; + if (base instanceof FieldEqualitor baseEq) { return leftFieldName.equals(baseEq.leftFieldName) && rightFieldName.equals(baseEq.rightFieldName); - } else if (base instanceof MultipleFieldEqualitor) { + } else if (base instanceof MultipleFieldEqualitor baseEqs) { // must equal the first one - MultipleFieldEqualitor baseEqs = (MultipleFieldEqualitor) base; if (baseEqs.getEqs().length > 0) { return isDerivedFrom(baseEqs.getEqs()[0]); } @@ -127,13 +125,11 @@ public boolean isDerivedFrom(StreamComparator base) { if (null == base) { return false; } - if (base instanceof FieldComparator) { - FieldComparator baseComp = (FieldComparator) base; + if (base instanceof FieldComparator baseComp) { return leftFieldName.equals(baseComp.getLeftFieldName()) || rightFieldName.equals(baseComp.getRightFieldName()); - } else if (base instanceof MultipleFieldComparator) { + } else if (base instanceof MultipleFieldComparator baseComps) { // must equal the first one - MultipleFieldComparator baseComps = (MultipleFieldComparator) base; if (baseComps.getComps().length > 0) { return isDerivedFrom(baseComps.getComps()[0]); } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eq/MultipleFieldEqualitor.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eq/MultipleFieldEqualitor.java index 92765bae52b..1889ce2fd8a 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eq/MultipleFieldEqualitor.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eq/MultipleFieldEqualitor.java @@ -75,8 +75,7 @@ public boolean isDerivedFrom(StreamEqualitor base) { if (null == base) { return false; } - if (base instanceof MultipleFieldEqualitor) { - MultipleFieldEqualitor baseEq = (MultipleFieldEqualitor) base; + if (base instanceof MultipleFieldEqualitor baseEq) { if (baseEq.eqs.length >= eqs.length) { for (int idx = 0; idx < eqs.length; ++idx) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/BicubicSplineEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/BicubicSplineEvaluator.java index 37ee06dc474..a5dbfb7ae1a 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/BicubicSplineEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/BicubicSplineEvaluator.java @@ -47,7 +47,7 @@ public Object doWork(Object... objects) throws IOException { double[] y = null; double[][] grid = null; - if (first instanceof List && second instanceof List && third instanceof Matrix) { + if (first instanceof List && second instanceof List && third instanceof Matrix matrix) { @SuppressWarnings({"unchecked"}) List xlist = (List) first; x = new double[xlist.size()]; @@ -64,7 +64,6 @@ public Object doWork(Object... objects) throws IOException { y[i] = ylist.get(i).doubleValue(); } - Matrix matrix = (Matrix) third; grid = matrix.getData(); PiecewiseBicubicSplineInterpolator interpolator = new PiecewiseBicubicSplineInterpolator(); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ColumnAtEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ColumnAtEvaluator.java index 08d0d898c94..06ceacfc0a9 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ColumnAtEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ColumnAtEvaluator.java @@ -42,8 +42,7 @@ public ColumnAtEvaluator(StreamExpression expression, StreamFactory factory) thr @Override public Object doWork(Object value1, Object value2) throws IOException { - if (value1 instanceof Matrix) { - Matrix matrix = (Matrix) value1; + if (value1 instanceof Matrix matrix) { Number index = (Number) value2; double[][] data = matrix.getData(); List list = new ArrayList<>(); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ColumnCountEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ColumnCountEvaluator.java index 78c89b7bf66..16fab16cfc9 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ColumnCountEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ColumnCountEvaluator.java @@ -32,7 +32,7 @@ public ColumnCountEvaluator(StreamExpression expression, StreamFactory factory) @Override public Object doWork(Object value) throws IOException { - if (!(value instanceof Matrix)) { + if (!(value instanceof Matrix matrix)) { throw new IOException( String.format( Locale.ROOT, @@ -40,7 +40,6 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory), value.getClass().getSimpleName())); } else { - Matrix matrix = (Matrix) value; return matrix.getColumnCount(); } } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/CorrelationEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/CorrelationEvaluator.java index 6e7695d702e..a7fb7dab334 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/CorrelationEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/CorrelationEvaluator.java @@ -127,8 +127,7 @@ public Object doWork(Object... values) throws IOException { return null; } } else if (values.length == 1) { - if (values[0] instanceof Matrix) { - Matrix matrix = (Matrix) values[0]; + if (values[0] instanceof Matrix matrix) { double[][] data = matrix.getData(); if (type.equals(CorrelationType.pearsons)) { PearsonsCorrelation pearsonsCorrelation = new PearsonsCorrelation(data); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/CorrelationSignificanceEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/CorrelationSignificanceEvaluator.java index 8c53ecd0373..b50b6d9c80b 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/CorrelationSignificanceEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/CorrelationSignificanceEvaluator.java @@ -45,11 +45,9 @@ public CorrelationSignificanceEvaluator(StreamExpression expression, StreamFacto public Object doWork(Object value) throws IOException { if (null == value) { return null; - } else if (value instanceof Matrix) { - Matrix matrix = (Matrix) value; + } else if (value instanceof Matrix matrix) { Object corr = matrix.getAttribute("corr"); - if (corr instanceof PearsonsCorrelation) { - PearsonsCorrelation pcorr = (PearsonsCorrelation) corr; + if (corr instanceof PearsonsCorrelation pcorr) { RealMatrix realMatrix = pcorr.getCorrelationPValues(); return new Matrix(realMatrix.getData()); } else { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/CumulativeProbabilityEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/CumulativeProbabilityEvaluator.java index ec0ae97533d..6a6add7c6f4 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/CumulativeProbabilityEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/CumulativeProbabilityEvaluator.java @@ -65,8 +65,7 @@ public Object doWork(Object first, Object second) throws IOException { first.getClass().getSimpleName())); } - if (first instanceof RealDistribution) { - RealDistribution rd = (RealDistribution) first; + if (first instanceof RealDistribution rd) { Number predictOver = (Number) second; return rd.cumulativeProbability(predictOver.doubleValue()); } else { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/DensityEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/DensityEvaluator.java index 9aef433d41f..ef8e155108a 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/DensityEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/DensityEvaluator.java @@ -33,7 +33,7 @@ public DensityEvaluator(StreamExpression expression, StreamFactory factory) thro @Override public Object doWork(Object first, Object second) throws IOException { - if (!(first instanceof MultivariateRealDistribution)) { + if (!(first instanceof MultivariateRealDistribution multivariateRealDistribution)) { throw new IOException( String.format( Locale.ROOT, @@ -50,8 +50,6 @@ public Object doWork(Object first, Object second) throws IOException { first.getClass().getSimpleName())); } - MultivariateRealDistribution multivariateRealDistribution = - (MultivariateRealDistribution) first; @SuppressWarnings({"unchecked"}) List nums = (List) second; diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/DerivativeEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/DerivativeEvaluator.java index 456ecdf7c65..ec2a3a3ae2f 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/DerivativeEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/DerivativeEvaluator.java @@ -42,7 +42,7 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory))); } - if (!(value instanceof VectorFunction)) { + if (!(value instanceof VectorFunction vectorFunction)) { throw new IOException( String.format( Locale.ROOT, @@ -51,8 +51,6 @@ public Object doWork(Object value) throws IOException { value.getClass().getSimpleName())); } - VectorFunction vectorFunction = (VectorFunction) value; - DifferentiableUnivariateFunction func = null; double[] x = (double[]) vectorFunction.getFromContext("x"); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/DistanceEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/DistanceEvaluator.java index 6c97942a711..9a4e39bf24e 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/DistanceEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/DistanceEvaluator.java @@ -46,8 +46,7 @@ public DistanceEvaluator(StreamExpression expression, StreamFactory factory) thr public Object doWork(Object... values) throws IOException { if (values.length == 1) { - if (values[0] instanceof Matrix) { - Matrix matrix = (Matrix) values[0]; + if (values[0] instanceof Matrix matrix) { EuclideanDistance euclideanDistance = new EuclideanDistance(); return distance(euclideanDistance, matrix); } else { @@ -74,8 +73,7 @@ public Object doWork(Object... values) throws IOException { toExpression(constructingFactory))); } - if (first instanceof Matrix) { - Matrix matrix = (Matrix) first; + if (first instanceof Matrix matrix) { DistanceMeasure distanceMeasure = (DistanceMeasure) second; return distance(distanceMeasure, matrix); } else { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/FeatureSelectEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/FeatureSelectEvaluator.java index 608a65accf2..f40dc11ecb9 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/FeatureSelectEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/FeatureSelectEvaluator.java @@ -45,8 +45,7 @@ public FeatureSelectEvaluator(StreamExpression expression, StreamFactory factory @Override public Object doWork(Object value1, Object value2) throws IOException { - if (value1 instanceof Matrix) { - Matrix matrix = (Matrix) value1; + if (value1 instanceof Matrix matrix) { double[][] data = matrix.getData(); List labels = matrix.getColumnLabels(); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/FieldValueEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/FieldValueEvaluator.java index 7eb2182b3b9..3c97c0d449e 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/FieldValueEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/FieldValueEvaluator.java @@ -63,8 +63,7 @@ public Object evaluate(Tuple tuple) throws IOException { // if we have an iterable that is not a list then convert to ArrayList // lists are good to go if (null != value) { - if (value instanceof Object[]) { - Object[] array = (Object[]) value; + if (value instanceof Object[] array) { List list = new ArrayList<>(array.length); for (Object obj : array) { list.add(obj); @@ -74,8 +73,7 @@ public Object evaluate(Tuple tuple) throws IOException { return value; } else if (value instanceof VectorFunction) { return value; - } else if (value instanceof Iterable && !(value instanceof List)) { - Iterable iter = (Iterable) value; + } else if (value instanceof Iterable iter && !(value instanceof List)) { List list = new ArrayList<>(); for (Object obj : iter) { list.add(obj); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAmplitudeEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAmplitudeEvaluator.java index 4aa5c04a975..c8f3281b6c4 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAmplitudeEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAmplitudeEvaluator.java @@ -32,7 +32,7 @@ public GetAmplitudeEvaluator(StreamExpression expression, StreamFactory factory) @Override public Object doWork(Object value) throws IOException { - if (!(value instanceof VectorFunction)) { + if (!(value instanceof VectorFunction vectorFunction)) { throw new IOException( String.format( Locale.ROOT, @@ -40,7 +40,6 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory), value.getClass().getSimpleName())); } else { - VectorFunction vectorFunction = (VectorFunction) value; return vectorFunction.getFromContext("amplitude"); } } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAngularFrequencyEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAngularFrequencyEvaluator.java index 522b4617468..66be054f75e 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAngularFrequencyEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAngularFrequencyEvaluator.java @@ -33,7 +33,7 @@ public GetAngularFrequencyEvaluator(StreamExpression expression, StreamFactory f @Override public Object doWork(Object value) throws IOException { - if (!(value instanceof VectorFunction)) { + if (!(value instanceof VectorFunction vectorFunction)) { throw new IOException( String.format( Locale.ROOT, @@ -41,7 +41,6 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory), value.getClass().getSimpleName())); } else { - VectorFunction vectorFunction = (VectorFunction) value; return vectorFunction.getFromContext("angularFrequency"); } } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAreaEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAreaEvaluator.java index 196cee3f873..2dbc032aee3 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAreaEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAreaEvaluator.java @@ -32,7 +32,7 @@ public GetAreaEvaluator(StreamExpression expression, StreamFactory factory) thro @Override public Object doWork(Object value) throws IOException { - if (!(value instanceof ConvexHull2D)) { + if (!(value instanceof ConvexHull2D convexHull2D)) { throw new IOException( String.format( Locale.ROOT, @@ -40,7 +40,6 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory), value.getClass().getSimpleName())); } else { - ConvexHull2D convexHull2D = (ConvexHull2D) value; return convexHull2D.createRegion().getSize(); } } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAttributeEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAttributeEvaluator.java index 7bbde085f4e..0ca14fab0dc 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAttributeEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAttributeEvaluator.java @@ -32,7 +32,7 @@ public GetAttributeEvaluator(StreamExpression expression, StreamFactory factory) @Override public Object doWork(Object value1, Object value2) throws IOException { - if (!(value1 instanceof Attributes)) { + if (!(value1 instanceof Attributes attributes)) { throw new IOException( String.format( Locale.ROOT, @@ -40,7 +40,6 @@ public Object doWork(Object value1, Object value2) throws IOException { toExpression(constructingFactory), value1.getClass().getSimpleName())); } else { - Attributes attributes = (Attributes) value1; String key = (String) value2; return attributes.getAttribute(key.replace("\"", "")); } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAttributesEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAttributesEvaluator.java index c4aec0d2fa1..e138496a6d7 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAttributesEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetAttributesEvaluator.java @@ -32,7 +32,7 @@ public GetAttributesEvaluator(StreamExpression expression, StreamFactory factory @Override public Object doWork(Object value) throws IOException { - if (!(value instanceof Attributes)) { + if (!(value instanceof Attributes attributes)) { throw new IOException( String.format( Locale.ROOT, @@ -40,7 +40,6 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory), value.getClass().getSimpleName())); } else { - Attributes attributes = (Attributes) value; return attributes.getAttributes(); } } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetBaryCenterEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetBaryCenterEvaluator.java index 7db3b4cc219..770025d6913 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetBaryCenterEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetBaryCenterEvaluator.java @@ -36,7 +36,7 @@ public GetBaryCenterEvaluator(StreamExpression expression, StreamFactory factory @Override public Object doWork(Object value) throws IOException { - if (!(value instanceof ConvexHull2D)) { + if (!(value instanceof ConvexHull2D convexHull2D)) { throw new IOException( String.format( Locale.ROOT, @@ -44,7 +44,6 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory), value.getClass().getSimpleName())); } else { - ConvexHull2D convexHull2D = (ConvexHull2D) value; Vector2D vector2D = (Vector2D) convexHull2D.createRegion().getBarycenter(); List vec = new ArrayList<>(); vec.add(vector2D.getX()); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetBoundarySizeEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetBoundarySizeEvaluator.java index 3aa5975f64e..0f688e71bd6 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetBoundarySizeEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetBoundarySizeEvaluator.java @@ -33,7 +33,7 @@ public GetBoundarySizeEvaluator(StreamExpression expression, StreamFactory facto @Override public Object doWork(Object value) throws IOException { - if (!(value instanceof ConvexHull2D)) { + if (!(value instanceof ConvexHull2D convexHull2D)) { throw new IOException( String.format( Locale.ROOT, @@ -41,7 +41,6 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory), value.getClass().getSimpleName())); } else { - ConvexHull2D convexHull2D = (ConvexHull2D) value; return convexHull2D.createRegion().getBoundarySize(); } } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetCenterEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetCenterEvaluator.java index d25b6f2f3e7..98c2ff9f642 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetCenterEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetCenterEvaluator.java @@ -35,7 +35,7 @@ public GetCenterEvaluator(StreamExpression expression, StreamFactory factory) th @Override public Object doWork(Object value) throws IOException { - if (!(value instanceof EnclosingBall)) { + if (!(value instanceof EnclosingBall enclosingBall)) { throw new IOException( String.format( Locale.ROOT, @@ -43,7 +43,6 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory), value.getClass().getSimpleName())); } else { - EnclosingBall enclosingBall = (EnclosingBall) value; Vector2D vec = (Vector2D) enclosingBall.getCenter(); List center = new ArrayList<>(); center.add(vec.getX()); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetCentroidsEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetCentroidsEvaluator.java index 5211ca7e07d..40a9690ecd4 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetCentroidsEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetCentroidsEvaluator.java @@ -35,7 +35,7 @@ public GetCentroidsEvaluator(StreamExpression expression, StreamFactory factory) @Override public Object doWork(Object value) throws IOException { - if (!(value instanceof KmeansEvaluator.ClusterTuple)) { + if (!(value instanceof KmeansEvaluator.ClusterTuple clusterTuple)) { throw new IOException( String.format( Locale.ROOT, @@ -43,7 +43,6 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory), value.getClass().getSimpleName())); } else { - KmeansEvaluator.ClusterTuple clusterTuple = (KmeansEvaluator.ClusterTuple) value; List> clusters = clusterTuple.getClusters(); double[][] data = new double[clusters.size()][]; for (int i = 0; i < clusters.size(); i++) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetClusterEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetClusterEvaluator.java index 0cf6192cd7a..31c10d43fb4 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetClusterEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetClusterEvaluator.java @@ -35,7 +35,7 @@ public GetClusterEvaluator(StreamExpression expression, StreamFactory factory) @Override public Object doWork(Object value1, Object value2) throws IOException { - if (!(value1 instanceof KmeansEvaluator.ClusterTuple)) { + if (!(value1 instanceof KmeansEvaluator.ClusterTuple clusterTuple)) { throw new IOException( String.format( Locale.ROOT, @@ -44,7 +44,6 @@ public Object doWork(Object value1, Object value2) throws IOException { value1.getClass().getSimpleName())); } else { - KmeansEvaluator.ClusterTuple clusterTuple = (KmeansEvaluator.ClusterTuple) value1; List> clusters = clusterTuple.getClusters(); Number index = (Number) value2; diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetColumnLabelsEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetColumnLabelsEvaluator.java index 224dad8d5e3..5e3be59d193 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetColumnLabelsEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetColumnLabelsEvaluator.java @@ -32,7 +32,7 @@ public GetColumnLabelsEvaluator(StreamExpression expression, StreamFactory facto @Override public Object doWork(Object value) throws IOException { - if (!(value instanceof Matrix)) { + if (!(value instanceof Matrix matrix)) { throw new IOException( String.format( Locale.ROOT, @@ -40,7 +40,6 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory), value.getClass().getSimpleName())); } else { - Matrix matrix = (Matrix) value; return matrix.getColumnLabels(); } } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetMembershipMatrixEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetMembershipMatrixEvaluator.java index 4369a31630a..62387b33675 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetMembershipMatrixEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetMembershipMatrixEvaluator.java @@ -33,7 +33,7 @@ public GetMembershipMatrixEvaluator(StreamExpression expression, StreamFactory f @Override public Object doWork(Object value) throws IOException { - if (!(value instanceof KmeansEvaluator.ClusterTuple)) { + if (!(value instanceof KmeansEvaluator.ClusterTuple clusterTuple)) { throw new IOException( String.format( Locale.ROOT, @@ -41,7 +41,6 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory), value.getClass().getSimpleName())); } else { - KmeansEvaluator.ClusterTuple clusterTuple = (KmeansEvaluator.ClusterTuple) value; return clusterTuple.getMembershipMatrix(); } } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetPhaseEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetPhaseEvaluator.java index 38fb8fc9762..0b46b2f9f3c 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetPhaseEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetPhaseEvaluator.java @@ -31,7 +31,7 @@ public GetPhaseEvaluator(StreamExpression expression, StreamFactory factory) thr @Override public Object doWork(Object value) throws IOException { - if (!(value instanceof VectorFunction)) { + if (!(value instanceof VectorFunction vectorFunction)) { throw new IOException( String.format( Locale.ROOT, @@ -39,7 +39,6 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory), value.getClass().getSimpleName())); } else { - VectorFunction vectorFunction = (VectorFunction) value; return vectorFunction.getFromContext("phase"); } } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetRadiusEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetRadiusEvaluator.java index e354b7202e7..f27c022ee98 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetRadiusEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetRadiusEvaluator.java @@ -32,7 +32,7 @@ public GetRadiusEvaluator(StreamExpression expression, StreamFactory factory) th @Override public Object doWork(Object value) throws IOException { - if (!(value instanceof EnclosingBall)) { + if (!(value instanceof EnclosingBall enclosingBall)) { throw new IOException( String.format( Locale.ROOT, @@ -40,7 +40,6 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory), value.getClass().getSimpleName())); } else { - EnclosingBall enclosingBall = (EnclosingBall) value; return enclosingBall.getRadius(); } } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetRowLabelsEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetRowLabelsEvaluator.java index e2f2786ea36..647d85d383a 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetRowLabelsEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetRowLabelsEvaluator.java @@ -32,7 +32,7 @@ public GetRowLabelsEvaluator(StreamExpression expression, StreamFactory factory) @Override public Object doWork(Object value) throws IOException { - if (!(value instanceof Matrix)) { + if (!(value instanceof Matrix matrix)) { throw new IOException( String.format( Locale.ROOT, @@ -40,7 +40,6 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory), value.getClass().getSimpleName())); } else { - Matrix matrix = (Matrix) value; return matrix.getRowLabels(); } } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetSupportPointsEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetSupportPointsEvaluator.java index 73e91abe994..1d50a73df9a 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetSupportPointsEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetSupportPointsEvaluator.java @@ -35,7 +35,7 @@ public GetSupportPointsEvaluator(StreamExpression expression, StreamFactory fact @Override public Object doWork(Object value) throws IOException { - if (!(value instanceof EnclosingBall)) { + if (!(value instanceof EnclosingBall enclosingBall)) { throw new IOException( String.format( Locale.ROOT, @@ -43,7 +43,6 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory), value.getClass().getSimpleName())); } else { - EnclosingBall enclosingBall = (EnclosingBall) value; Point[] points = enclosingBall.getSupport(); double[][] data = new double[points.length][2]; int i = 0; diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetValueEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetValueEvaluator.java index 275ab4a0375..ce40dcb717d 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetValueEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetValueEvaluator.java @@ -41,8 +41,7 @@ public GetValueEvaluator(StreamExpression expression, StreamFactory factory) thr @Override public Object doWork(Object value1, Object value2) throws IOException { - if (value1 instanceof Tuple) { - Tuple tuple = (Tuple) value1; + if (value1 instanceof Tuple tuple) { String key = (String) value2; key = key.replace("\"", ""); return tuple.get(key); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetVerticesEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetVerticesEvaluator.java index ef4a119c39f..d652168db54 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetVerticesEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GetVerticesEvaluator.java @@ -34,7 +34,7 @@ public GetVerticesEvaluator(StreamExpression expression, StreamFactory factory) @Override public Object doWork(Object value) throws IOException { - if (!(value instanceof ConvexHull2D)) { + if (!(value instanceof ConvexHull2D convexHull2D)) { throw new IOException( String.format( Locale.ROOT, @@ -42,7 +42,6 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory), value.getClass().getSimpleName())); } else { - ConvexHull2D convexHull2D = (ConvexHull2D) value; Vector2D[] vectors = convexHull2D.getVertices(); double[][] data = new double[vectors.length][2]; for (int i = 0; i < vectors.length; i++) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GrandSumEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GrandSumEvaluator.java index a7d88f84eec..01ef2796a7c 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GrandSumEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/GrandSumEvaluator.java @@ -41,8 +41,7 @@ public GrandSumEvaluator(StreamExpression expression, StreamFactory factory) thr public Object doWork(Object value) throws IOException { if (null == value) { return null; - } else if (value instanceof Matrix) { - Matrix matrix = (Matrix) value; + } else if (value instanceof Matrix matrix) { double[][] data = matrix.getData(); double grandSum = 0; for (double[] row : data) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/IFFTEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/IFFTEvaluator.java index a1f74df025f..825fd822293 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/IFFTEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/IFFTEvaluator.java @@ -46,9 +46,8 @@ public IFFTEvaluator(StreamExpression expression, StreamFactory factory) throws @Override public Object doWork(Object v) throws IOException { - if (v instanceof Matrix) { + if (v instanceof Matrix matrix) { - Matrix matrix = (Matrix) v; double[][] data = matrix.getData(); double[] real = data[0]; double[] imaginary = data[1]; diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/IndexOfEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/IndexOfEvaluator.java index 5f6cd28825e..4c31cfefbf4 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/IndexOfEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/IndexOfEvaluator.java @@ -32,7 +32,7 @@ public IndexOfEvaluator(StreamExpression expression, StreamFactory factory) thro @Override public Object doWork(Object value1, Object value2) throws IOException { - if (!(value1 instanceof List)) { + if (!(value1 instanceof List list)) { throw new IOException( String.format( Locale.ROOT, @@ -40,7 +40,6 @@ public Object doWork(Object value1, Object value2) throws IOException { toExpression(constructingFactory), value1.getClass().getSimpleName())); } else { - List list = (List) value1; String find = value2.toString().replace("\"", ""); for (int i = 0; i < list.size(); i++) { Object o = list.get(i); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/IntegrateEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/IntegrateEvaluator.java index d4cb1357cf8..2135b5cea9e 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/IntegrateEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/IntegrateEvaluator.java @@ -38,7 +38,7 @@ public Object doWork(Object... values) throws IOException { throw new IOException("The integrate function requires at most 3 parameters"); } - if (!(values[0] instanceof VectorFunction)) { + if (!(values[0] instanceof VectorFunction vectorFunction)) { throw new IOException( String.format( Locale.ROOT, @@ -47,13 +47,10 @@ public Object doWork(Object... values) throws IOException { values[0].getClass().getSimpleName())); } - VectorFunction vectorFunction = (VectorFunction) values[0]; - if (!(vectorFunction.getFunction() instanceof UnivariateFunction)) { + if (!(vectorFunction.getFunction() instanceof UnivariateFunction func)) { throw new IOException("Cannot evaluate integral from parameter."); } - UnivariateFunction func = (UnivariateFunction) vectorFunction.getFunction(); - if (values.length == 3) { Number min = null; diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/KolmogorovSmirnovEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/KolmogorovSmirnovEvaluator.java index 1f145773cbf..42f7df7b68e 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/KolmogorovSmirnovEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/KolmogorovSmirnovEvaluator.java @@ -69,8 +69,7 @@ public Object doWork(Object first, Object second) throws IOException { double[] data = ((List) second).stream().mapToDouble(item -> ((Number) item).doubleValue()).toArray(); - if (first instanceof RealDistribution) { - RealDistribution realDistribution = (RealDistribution) first; + if (first instanceof RealDistribution realDistribution) { Tuple tuple = new Tuple(); tuple.put(StreamParams.P_VALUE, ks.kolmogorovSmirnovTest(realDistribution, data)); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/LatLonVectorsEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/LatLonVectorsEvaluator.java index b223ac6b0bf..46fff79d808 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/LatLonVectorsEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/LatLonVectorsEvaluator.java @@ -64,11 +64,10 @@ public Object doWork(Object... objects) throws IOException { if (objects.length == 1) { // Just docs - if (!(objects[0] instanceof List)) { + if (!(objects[0] instanceof List list)) { throw new IOException( "The latlonVectors function expects a list of Tuples as a parameter."); } else { - List list = (List) objects[0]; if (list.size() > 0) { Object o = list.get(0); if (!(o instanceof Tuple)) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/LeftShiftEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/LeftShiftEvaluator.java index 7ced755973b..a466be899ad 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/LeftShiftEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/LeftShiftEvaluator.java @@ -41,8 +41,7 @@ public LeftShiftEvaluator(StreamExpression expression, StreamFactory factory) th @Override public Object doWork(Object value1, Object value2) throws IOException { - if (value1 instanceof List && value2 instanceof Number) { - List actual = (List) value1; + if (value1 instanceof List actual && value2 instanceof Number) { int val = ((Number) value2).intValue(); List shifted = new ArrayList<>(); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MarkovChainEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MarkovChainEvaluator.java index 3259ce67bc9..ab2465862a8 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MarkovChainEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MarkovChainEvaluator.java @@ -50,8 +50,7 @@ public Object doWork(Object... values) throws IOException { state = ((Number) values[1]).intValue(); } - if (values[0] instanceof Matrix) { - Matrix matrix = (Matrix) values[0]; + if (values[0] instanceof Matrix matrix) { return new MarkovChain(matrix, state); } else { throw new IOException("matrix parameter expected for markovChain function"); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MatrixMultiplyEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MatrixMultiplyEvaluator.java index 2e02a1e152f..885bee9d59b 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MatrixMultiplyEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MatrixMultiplyEvaluator.java @@ -55,8 +55,7 @@ public Object doWork(Object first, Object second) throws IOException { } private Array2DRowRealMatrix getMatrix(Object o) throws IOException { - if (o instanceof Matrix) { - Matrix matrix = (Matrix) o; + if (o instanceof Matrix matrix) { return new Array2DRowRealMatrix(matrix.getData(), false); } else if (o instanceof List) { @SuppressWarnings({"unchecked"}) diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MemsetEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MemsetEvaluator.java index 4a2cdd4c656..d248d5def9c 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MemsetEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MemsetEvaluator.java @@ -70,7 +70,7 @@ public MemsetEvaluator(StreamExpression expression, StreamFactory factory) throw } if (null == colsExpression - || !(colsExpression.getParameter() instanceof StreamExpressionValue)) { + || !(colsExpression.getParameter() instanceof StreamExpressionValue colsExpressionValue)) { throw new IOException( String.format( Locale.ROOT, @@ -79,7 +79,7 @@ public MemsetEvaluator(StreamExpression expression, StreamFactory factory) throw } if (null == varsExpression - || !(varsExpression.getParameter() instanceof StreamExpressionValue)) { + || !(varsExpression.getParameter() instanceof StreamExpressionValue varsExpressionValue)) { throw new IOException( String.format( Locale.ROOT, @@ -96,10 +96,6 @@ public MemsetEvaluator(StreamExpression expression, StreamFactory factory) throw in = factory.constructStream(streamExpressions.get(0)); - StreamExpressionValue colsExpressionValue = - (StreamExpressionValue) colsExpression.getParameter(); - StreamExpressionValue varsExpressionValue = - (StreamExpressionValue) varsExpression.getParameter(); String colsString = colsExpressionValue.getValue(); String varsString = varsExpressionValue.getValue(); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MinMaxScaleEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MinMaxScaleEvaluator.java index c88e04071bd..f77382bbe7d 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MinMaxScaleEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MinMaxScaleEvaluator.java @@ -45,8 +45,7 @@ public Object doWork(Object... values) throws IOException { max = ((Number) values[2]).doubleValue(); } - if (values[0] instanceof Matrix) { - Matrix matrix = (Matrix) values[0]; + if (values[0] instanceof Matrix matrix) { double[][] data = matrix.getData(); double[][] scaled = new double[data.length][]; for (int i = 0; i < scaled.length; i++) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MonteCarloEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MonteCarloEvaluator.java index 5bb63d9d765..9d090f3c5c0 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MonteCarloEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MonteCarloEvaluator.java @@ -113,9 +113,8 @@ private void populateVariables(Tuple contextTuple) throws IOException { for (Map.Entry entry : entries) { String name = entry.getKey(); Object o = entry.getValue(); - if (o instanceof TupleStream) { + if (o instanceof TupleStream tStream) { List tuples = new ArrayList<>(); - TupleStream tStream = (TupleStream) o; tStream.setStreamContext(streamContext); try { tStream.open(); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MovingAverageEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MovingAverageEvaluator.java index 4fc666c4450..3eb8ef51f4e 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MovingAverageEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MovingAverageEvaluator.java @@ -48,7 +48,7 @@ public Object doWork(Object first, Object second) throws IOException { "Invalid expression %s - null found for the second value", toExpression(constructingFactory))); } - if (!(first instanceof List)) { + if (!(first instanceof List values)) { throw new IOException( String.format( Locale.ROOT, @@ -65,7 +65,6 @@ public Object doWork(Object first, Object second) throws IOException { first.getClass().getSimpleName())); } - List values = (List) first; int window = ((Number) second).intValue(); List moving = new ArrayList<>(); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MovingMADEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MovingMADEvaluator.java index a7b3295aaf7..09c7bf4a5f7 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MovingMADEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MovingMADEvaluator.java @@ -47,7 +47,7 @@ public Object doWork(Object first, Object second) throws IOException { "Invalid expression %s - null found for the second value", toExpression(constructingFactory))); } - if (!(first instanceof List)) { + if (!(first instanceof List values)) { throw new IOException( String.format( Locale.ROOT, @@ -64,7 +64,6 @@ public Object doWork(Object first, Object second) throws IOException { first.getClass().getSimpleName())); } - List values = (List) first; int window = ((Number) second).intValue(); List moving = new ArrayList<>(); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MovingMedianEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MovingMedianEvaluator.java index 03b59e6bb27..533ea09522c 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MovingMedianEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/MovingMedianEvaluator.java @@ -49,7 +49,7 @@ public Object doWork(Object first, Object second) throws IOException { "Invalid expression %s - null found for the second value", toExpression(constructingFactory))); } - if (!(first instanceof List)) { + if (!(first instanceof List values)) { throw new IOException( String.format( Locale.ROOT, @@ -66,7 +66,6 @@ public Object doWork(Object first, Object second) throws IOException { first.getClass().getSimpleName())); } - List values = (List) first; int window = ((Number) second).intValue(); List moving = new ArrayList<>(); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/NormalizeEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/NormalizeEvaluator.java index 73f57512b5f..30365fd272c 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/NormalizeEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/NormalizeEvaluator.java @@ -55,8 +55,7 @@ public Object doWork(Object value) { .toArray())) .boxed() .collect(Collectors.toList()); - } else if (value instanceof Matrix) { - Matrix matrix = (Matrix) value; + } else if (value instanceof Matrix matrix) { double[][] data = matrix.getData(); double[][] standardized = new double[data.length][]; for (int i = 0; i < data.length; i++) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/NormalizeSumEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/NormalizeSumEvaluator.java index f5d80d87464..3c2002bebb2 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/NormalizeSumEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/NormalizeSumEvaluator.java @@ -55,8 +55,7 @@ public Object doWork(Object... values) throws IOException { if (null == value) { return null; - } else if (value instanceof Matrix) { - Matrix matrix = (Matrix) value; + } else if (value instanceof Matrix matrix) { double[][] data = matrix.getData(); double[][] unitData = new double[data.length][]; diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/OutliersEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/OutliersEvaluator.java index 96ca69de0af..b4cacc96ead 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/OutliersEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/OutliersEvaluator.java @@ -85,9 +85,7 @@ public Object doWork(Object... values) throws IOException { List outliers = new ArrayList<>(); - if (dist instanceof IntegerDistribution) { - - IntegerDistribution d = (IntegerDistribution) dist; + if (dist instanceof IntegerDistribution d) { for (int i = 0; i < vec.size(); i++) { @@ -110,9 +108,8 @@ public Object doWork(Object... values) throws IOException { return outliers; - } else if (dist instanceof AbstractRealDistribution) { + } else if (dist instanceof AbstractRealDistribution d) { - AbstractRealDistribution d = (AbstractRealDistribution) dist; for (int i = 0; i < vec.size(); i++) { Number n = vec.get(i); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/PowerEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/PowerEvaluator.java index 6efa9ce6b7e..3bacde26493 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/PowerEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/PowerEvaluator.java @@ -47,10 +47,8 @@ public Object doWork(Object first, Object second) throws IOException { return null; } - if (first instanceof Number) { - Number value = (Number) first; - if (second instanceof Number) { - Number exponent = (Number) second; + if (first instanceof Number value) { + if (second instanceof Number exponent) { return Math.pow(value.doubleValue(), exponent.doubleValue()); } else if (second instanceof List) { @SuppressWarnings({"unchecked"}) @@ -67,8 +65,7 @@ public Object doWork(Object first, Object second) throws IOException { } else if (first instanceof List) { @SuppressWarnings({"unchecked"}) List values = (List) first; - if (second instanceof Number) { - Number exponent = (Number) second; + if (second instanceof Number exponent) { List out = new ArrayList<>(values.size()); for (Number value : values) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/PrecisionEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/PrecisionEvaluator.java index ab0fb8b799b..1fd86ccb1ba 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/PrecisionEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/PrecisionEvaluator.java @@ -49,9 +49,8 @@ public Object doWork(Object value, Object value2) { .stream() .map(innerValue -> doWork(innerValue, ((Number) value2).intValue())) .collect(Collectors.toList()); - } else if (value instanceof Matrix) { + } else if (value instanceof Matrix matrix) { int p = ((Number) value2).intValue(); - Matrix matrix = (Matrix) value; double[][] data = matrix.getData(); for (int i = 0; i < data.length; ++i) { for (int j = 0; j < data[i].length; j++) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/PredictEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/PredictEvaluator.java index 83491cf38dc..026a630df0d 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/PredictEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/PredictEvaluator.java @@ -66,10 +66,8 @@ public Object doWork(Object... objects) throws IOException { first.getClass().getSimpleName())); } - if (first instanceof RegressionEvaluator.RegressionTuple) { + if (first instanceof RegressionEvaluator.RegressionTuple regressedTuple) { - RegressionEvaluator.RegressionTuple regressedTuple = - (RegressionEvaluator.RegressionTuple) first; if (second instanceof Number) { return regressedTuple.predict(((Number) second).doubleValue()); } else { @@ -79,10 +77,8 @@ public Object doWork(Object... objects) throws IOException { .collect(Collectors.toList()); } - } else if (first instanceof OLSRegressionEvaluator.MultipleRegressionTuple) { + } else if (first instanceof OLSRegressionEvaluator.MultipleRegressionTuple regressedTuple) { - OLSRegressionEvaluator.MultipleRegressionTuple regressedTuple = - (OLSRegressionEvaluator.MultipleRegressionTuple) first; if (second instanceof List) { @SuppressWarnings({"unchecked"}) List list = (List) second; @@ -93,9 +89,8 @@ public Object doWork(Object... objects) throws IOException { } return regressedTuple.predict(predictors); - } else if (second instanceof Matrix) { + } else if (second instanceof Matrix m) { - Matrix m = (Matrix) second; double[][] data = m.getData(); List predictions = new ArrayList<>(); for (double[] predictors : data) { @@ -104,9 +99,7 @@ public Object doWork(Object... objects) throws IOException { return predictions; } - } else if (first instanceof KnnRegressionEvaluator.KnnRegressionTuple) { - KnnRegressionEvaluator.KnnRegressionTuple regressedTuple = - (KnnRegressionEvaluator.KnnRegressionTuple) first; + } else if (first instanceof KnnRegressionEvaluator.KnnRegressionTuple regressedTuple) { if (regressedTuple.getBivariate()) { // Handle bi-variate regression @@ -141,9 +134,8 @@ public Object doWork(Object... objects) throws IOException { } return regressedTuple.predict(predictors); - } else if (second instanceof Matrix) { + } else if (second instanceof Matrix m) { - Matrix m = (Matrix) second; if (regressedTuple.getScale()) { m = regressedTuple.scale(m); } @@ -155,8 +147,7 @@ public Object doWork(Object... objects) throws IOException { return predictions; } } - } else if (first instanceof VectorFunction) { - VectorFunction vectorFunction = (VectorFunction) first; + } else if (first instanceof VectorFunction vectorFunction) { UnivariateFunction univariateFunction = (UnivariateFunction) vectorFunction.getFunction(); if (second instanceof Number) { double x = ((Number) second).doubleValue(); @@ -167,8 +158,7 @@ public Object doWork(Object... objects) throws IOException { .map(value -> univariateFunction.value(((Number) value).doubleValue())) .collect(Collectors.toList()); } - } else if (first instanceof BivariateFunction) { - BivariateFunction bivariateFunction = (BivariateFunction) first; + } else if (first instanceof BivariateFunction bivariateFunction) { if (objects.length == 3) { Object third = objects[2]; double x = 0.0; @@ -181,8 +171,7 @@ public Object doWork(Object... objects) throws IOException { throw new IOException("BivariateFunction requires two numeric parameters."); } } else if (objects.length == 2) { - if (second instanceof Matrix) { - Matrix m = (Matrix) second; + if (second instanceof Matrix m) { double[][] data = m.getData(); if (data[0].length == 2) { List out = new ArrayList<>(); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ProbabilityEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ProbabilityEvaluator.java index 31ec03be479..c109b17a9e3 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ProbabilityEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ProbabilityEvaluator.java @@ -56,7 +56,7 @@ public Object doWork(Object... values) throws IOException { "Invalid expression %s - null found for the second value", toExpression(constructingFactory))); } - if (!(first instanceof IntegerDistribution)) { + if (!(first instanceof IntegerDistribution d)) { throw new IOException( String.format( Locale.ROOT, @@ -64,7 +64,7 @@ public Object doWork(Object... values) throws IOException { toExpression(constructingFactory), first.getClass().getSimpleName())); } - if (!(second instanceof Number)) { + if (!(second instanceof Number predictOver)) { throw new IOException( String.format( Locale.ROOT, @@ -73,8 +73,6 @@ public Object doWork(Object... values) throws IOException { first.getClass().getSimpleName())); } - IntegerDistribution d = (IntegerDistribution) first; - Number predictOver = (Number) second; return d.probability(predictOver.intValue()); } else if (values.length == 3) { @@ -82,7 +80,7 @@ public Object doWork(Object... values) throws IOException { second = values[1]; third = values[2]; - if (!(first instanceof AbstractRealDistribution)) { + if (!(first instanceof AbstractRealDistribution realDistribution)) { throw new IOException( String.format( Locale.ROOT, @@ -90,7 +88,7 @@ public Object doWork(Object... values) throws IOException { toExpression(constructingFactory), first.getClass().getSimpleName())); } - if (!(second instanceof Number)) { + if (!(second instanceof Number start)) { throw new IOException( String.format( Locale.ROOT, @@ -99,7 +97,7 @@ public Object doWork(Object... values) throws IOException { first.getClass().getSimpleName())); } - if (!(third instanceof Number)) { + if (!(third instanceof Number end)) { throw new IOException( String.format( Locale.ROOT, @@ -108,9 +106,6 @@ public Object doWork(Object... values) throws IOException { first.getClass().getSimpleName())); } - AbstractRealDistribution realDistribution = (AbstractRealDistribution) first; - Number start = (Number) second; - Number end = (Number) third; return realDistribution.probability(start.doubleValue(), end.doubleValue()); } else { throw new IOException("The probability function expects 2 or 3 parameters"); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ProjectToBorderEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ProjectToBorderEvaluator.java index 0c6a5b8021c..80a057fb581 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ProjectToBorderEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ProjectToBorderEvaluator.java @@ -37,7 +37,7 @@ public ProjectToBorderEvaluator(StreamExpression expression, StreamFactory facto @Override public Object doWork(Object value1, Object value2) throws IOException { - if (!(value1 instanceof ConvexHull2D)) { + if (!(value1 instanceof ConvexHull2D convexHull2D)) { throw new IOException( String.format( Locale.ROOT, @@ -46,7 +46,7 @@ public Object doWork(Object value1, Object value2) throws IOException { value1.getClass().getSimpleName())); } - if (!(value2 instanceof Matrix)) { + if (!(value2 instanceof Matrix matrix)) { throw new IOException( String.format( Locale.ROOT, @@ -55,8 +55,6 @@ public Object doWork(Object value1, Object value2) throws IOException { value2.getClass().getSimpleName())); } - ConvexHull2D convexHull2D = (ConvexHull2D) value1; - Matrix matrix = (Matrix) value2; double[][] data = matrix.getData(); Region region = convexHull2D.createRegion(); double[][] borderPoints = new double[data.length][2]; diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RecursiveEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RecursiveEvaluator.java index a30d633b8df..dce2fdfd734 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RecursiveEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RecursiveEvaluator.java @@ -112,8 +112,7 @@ protected Object normalizeOutputType(Object value) { return null; } else if (value instanceof VectorFunction) { return value; - } else if (value instanceof BigDecimal) { - BigDecimal bd = (BigDecimal) value; + } else if (value instanceof BigDecimal bd) { return bd.doubleValue(); } else if (value instanceof Long || value instanceof Integer) { return ((Number) value).longValue(); @@ -125,11 +124,10 @@ protected Object normalizeOutputType(Object value) { // normalize each value in the list return ((List) value) .stream().map(innerValue -> normalizeOutputType(innerValue)).collect(Collectors.toList()); - } else if (value instanceof Tuple && value.getClass().getEnclosingClass() == null) { + } else if (value instanceof Tuple tuple && value.getClass().getEnclosingClass() == null) { // If it's a tuple and not an inner class that has extended tuple, which occurs in a number of // cases so that mathematical models can be contained within a tuple. - Tuple tuple = (Tuple) value; Tuple newTuple = new Tuple(); for (String s : tuple.getFields().keySet()) { Object v = tuple.get(s); @@ -152,9 +150,8 @@ public RecursiveEvaluator( factory.getOperandsOfType(expression, StreamExpressionParameter.class); for (StreamExpressionParameter parameter : parameters) { - if (parameter instanceof StreamExpression) { + if (parameter instanceof StreamExpression streamExpression) { // possible evaluator - StreamExpression streamExpression = (StreamExpression) parameter; if (factory.doesRepresentTypes(streamExpression, RecursiveEvaluator.class)) { containedEvaluators.add(factory.constructEvaluator(streamExpression)); } else if (factory.doesRepresentTypes(streamExpression, SourceEvaluator.class)) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RecursiveTemporalEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RecursiveTemporalEvaluator.java index 385f3bf666b..f6ef1faf004 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RecursiveTemporalEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RecursiveTemporalEvaluator.java @@ -79,8 +79,7 @@ public Object normalizeInputType(Object value) throws StreamEvaluatorException { } else if (value instanceof Date) { // Convert to Instant and recurse in return normalizeInputType(((Date) value).toInstant()); - } else if (value instanceof String) { - String valueStr = (String) value; + } else if (value instanceof String valueStr) { if (!valueStr.isEmpty()) { try { // Convert to Instant and recurse in diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ReverseEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ReverseEvaluator.java index dbe7839b61b..e80f8bc3719 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ReverseEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ReverseEvaluator.java @@ -43,8 +43,7 @@ public ReverseEvaluator(StreamExpression expression, StreamFactory factory) thro public Object doWork(Object value) { if (null == value) { return null; - } else if (value instanceof List) { - List actual = (List) value; + } else if (value instanceof List actual) { List reversed = new ArrayList<>(); for (int idx = actual.size() - 1; idx >= 0; --idx) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RightShiftEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RightShiftEvaluator.java index 9d6e255733a..19ab1652f02 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RightShiftEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RightShiftEvaluator.java @@ -42,8 +42,7 @@ public RightShiftEvaluator(StreamExpression expression, StreamFactory factory) @Override public Object doWork(Object value1, Object value2) throws IOException { - if (value1 instanceof List && value2 instanceof Number) { - List actual = (List) value1; + if (value1 instanceof List actual && value2 instanceof Number) { int val = ((Number) value2).intValue(); List shifted = new ArrayList<>(); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RowAtEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RowAtEvaluator.java index baec6c5d34f..57f0b63eb07 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RowAtEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RowAtEvaluator.java @@ -42,8 +42,7 @@ public RowAtEvaluator(StreamExpression expression, StreamFactory factory) throws @Override public Object doWork(Object value1, Object value2) throws IOException { - if (value1 instanceof Matrix) { - Matrix matrix = (Matrix) value1; + if (value1 instanceof Matrix matrix) { Number index = (Number) value2; double[] row = matrix.getData()[index.intValue()]; List list = new ArrayList<>(); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RowCountEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RowCountEvaluator.java index 4573d9935bf..e1049988b4e 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RowCountEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/RowCountEvaluator.java @@ -31,7 +31,7 @@ public RowCountEvaluator(StreamExpression expression, StreamFactory factory) thr @Override public Object doWork(Object value) throws IOException { - if (!(value instanceof Matrix)) { + if (!(value instanceof Matrix matrix)) { throw new IOException( String.format( Locale.ROOT, @@ -39,7 +39,6 @@ public Object doWork(Object value) throws IOException { toExpression(constructingFactory), value.getClass().getSimpleName())); } else { - Matrix matrix = (Matrix) value; return matrix.getRowCount(); } } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SampleEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SampleEvaluator.java index 80e057277c7..466a7c82566 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SampleEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SampleEvaluator.java @@ -67,8 +67,7 @@ public Object doWork(Object... objects) throws IOException { second = objects[1]; } - if (first instanceof MarkovChainEvaluator.MarkovChain) { - MarkovChainEvaluator.MarkovChain markovChain = (MarkovChainEvaluator.MarkovChain) first; + if (first instanceof MarkovChainEvaluator.MarkovChain markovChain) { if (second != null) { return Arrays.stream(markovChain.sample(((Number) second).intValue())) .mapToObj(item -> item) @@ -76,8 +75,7 @@ public Object doWork(Object... objects) throws IOException { } else { return markovChain.sample(); } - } else if (first instanceof RealDistribution) { - RealDistribution realDistribution = (RealDistribution) first; + } else if (first instanceof RealDistribution realDistribution) { if (second != null) { return Arrays.stream(realDistribution.sample(((Number) second).intValue())) .mapToObj(item -> item) diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ScalarAddEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ScalarAddEvaluator.java index 12302c302bf..4710a4f6ed8 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ScalarAddEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ScalarAddEvaluator.java @@ -53,8 +53,7 @@ public Object doWork(Object value1, Object value2) throws IOException { return out; - } else if (value2 instanceof Matrix) { - Matrix matrix = (Matrix) value2; + } else if (value2 instanceof Matrix matrix) { double[][] data = matrix.getData(); double[][] newData = new double[data.length][]; for (int i = 0; i < data.length; i++) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SetColumnLabelsEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SetColumnLabelsEvaluator.java index 862230bf46a..cbafc838bc4 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SetColumnLabelsEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SetColumnLabelsEvaluator.java @@ -41,7 +41,7 @@ public Object doWork(Object value1, Object value2) throws IOException { "Invalid expression %s - found type %s for value, expecting a Matrix", toExpression(constructingFactory), value1.getClass().getSimpleName())); - } else if (!(value2 instanceof List)) { + } else if (!(value2 instanceof List colLabels)) { throw new IOException( String.format( Locale.ROOT, @@ -51,7 +51,6 @@ public Object doWork(Object value1, Object value2) throws IOException { } else { Matrix matrix = (Matrix) value1; - List colLabels = (List) value2; // Convert numeric labels to strings. List strLabels = new ArrayList<>(colLabels.size()); for (Object o : colLabels) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SetRowLabelsEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SetRowLabelsEvaluator.java index d5a39e06698..7f38d66d837 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SetRowLabelsEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SetRowLabelsEvaluator.java @@ -41,7 +41,7 @@ public Object doWork(Object value1, Object value2) throws IOException { "Invalid expression %s - found type %s for value, expecting a Matrix", toExpression(constructingFactory), value1.getClass().getSimpleName())); - } else if (!(value2 instanceof List)) { + } else if (!(value2 instanceof List rowlabels)) { throw new IOException( String.format( Locale.ROOT, @@ -50,7 +50,6 @@ public Object doWork(Object value1, Object value2) throws IOException { value2.getClass().getSimpleName())); } else { Matrix matrix = (Matrix) value1; - List rowlabels = (List) value2; // Convert numeric labels to strings. diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SetValueEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SetValueEvaluator.java index 8a68027d73d..2a41a941b1f 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SetValueEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SetValueEvaluator.java @@ -40,8 +40,7 @@ public SetValueEvaluator(StreamExpression expression, StreamFactory factory) thr @Override public Object doWork(Object... values) throws IOException { - if (values[0] instanceof Tuple) { - Tuple tuple = (Tuple) values[0]; + if (values[0] instanceof Tuple tuple) { String key = (String) values[1]; Object value = values[2]; if (value instanceof String) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SumColumnsEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SumColumnsEvaluator.java index f84dfe7a5de..560bc1db791 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SumColumnsEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SumColumnsEvaluator.java @@ -46,10 +46,9 @@ public SumColumnsEvaluator(StreamExpression expression, StreamFactory factory) public Object doWork(Object value) throws IOException { if (null == value) { return null; - } else if (value instanceof Matrix) { + } else if (value instanceof Matrix matrix) { // First transpose the matrix - Matrix matrix = (Matrix) value; double[][] data = matrix.getData(); RealMatrix realMatrix = new Array2DRowRealMatrix(data, false); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SumRowsEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SumRowsEvaluator.java index 9012282de76..41e141ce467 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SumRowsEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/SumRowsEvaluator.java @@ -43,9 +43,8 @@ public SumRowsEvaluator(StreamExpression expression, StreamFactory factory) thro public Object doWork(Object value) throws IOException { if (null == value) { return null; - } else if (value instanceof Matrix) { + } else if (value instanceof Matrix matrix) { - Matrix matrix = (Matrix) value; double[][] data = matrix.getData(); List sums = new ArrayList<>(data.length); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/TermVectorsEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/TermVectorsEvaluator.java index 2d91573a793..c776b52a5bd 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/TermVectorsEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/TermVectorsEvaluator.java @@ -71,10 +71,9 @@ public Object doWork(Object... objects) throws IOException { if (objects.length == 1) { // Just docs - if (!(objects[0] instanceof List)) { + if (!(objects[0] instanceof List list)) { throw new IOException("The termVectors function expects a list of Tuples as a parameter."); } else { - List list = (List) objects[0]; if (list.size() > 0) { Object o = list.get(0); if (!(o instanceof Tuple)) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/TimeDifferencingEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/TimeDifferencingEvaluator.java index 110ced40345..a6ce8c665a2 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/TimeDifferencingEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/TimeDifferencingEvaluator.java @@ -95,11 +95,10 @@ public Object doWork(Object... values) throws IOException { (timeseriesValues.get(n).doubleValue() - timeseriesValues.get(n - lag).doubleValue())) .collect(Collectors.toList()); - } else if (values[0] instanceof Matrix) { + } else if (values[0] instanceof Matrix matrix) { // Diff each row of the matrix - Matrix matrix = (Matrix) values[0]; double[][] data = matrix.getData(); double[][] diffedData = new double[data.length][]; Number lagValue = 1; diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/TopFeaturesEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/TopFeaturesEvaluator.java index c69ffd9091f..af15878d645 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/TopFeaturesEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/TopFeaturesEvaluator.java @@ -46,9 +46,8 @@ public Object doWork(Object value1, Object value2) throws IOException { int k = ((Number) value2).intValue(); - if (value1 instanceof Matrix) { + if (value1 instanceof Matrix matrix) { - Matrix matrix = (Matrix) value1; List features = matrix.getColumnLabels(); if (features == null) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/TransposeEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/TransposeEvaluator.java index 796dada81ad..b23a81f1582 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/TransposeEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/TransposeEvaluator.java @@ -42,8 +42,7 @@ public TransposeEvaluator(StreamExpression expression, StreamFactory factory) th public Object doWork(Object value) throws IOException { if (null == value) { return null; - } else if (value instanceof Matrix) { - Matrix matrix = (Matrix) value; + } else if (value instanceof Matrix matrix) { double[][] data = matrix.getData(); Array2DRowRealMatrix amatrix = new Array2DRowRealMatrix(data, false); Array2DRowRealMatrix tmatrix = (Array2DRowRealMatrix) amatrix.transpose(); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/UnitEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/UnitEvaluator.java index 918ef3cb6db..02d2b578986 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/UnitEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/UnitEvaluator.java @@ -45,8 +45,7 @@ public UnitEvaluator(StreamExpression expression, StreamFactory factory) throws public Object doWork(Object value) throws IOException { if (null == value) { return null; - } else if (value instanceof Matrix) { - Matrix matrix = (Matrix) value; + } else if (value instanceof Matrix matrix) { double[][] data = matrix.getData(); double[][] unitData = new double[data.length][]; for (int i = 0; i < data.length; i++) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ValueAtEvaluator.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ValueAtEvaluator.java index 42da4748e03..e5f2a3f55fb 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ValueAtEvaluator.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/eval/ValueAtEvaluator.java @@ -47,9 +47,8 @@ public Object doWork(Object... values) throws IOException { } return c.get(index); - } else if (values[0] instanceof Matrix) { + } else if (values[0] instanceof Matrix c) { - Matrix c = (Matrix) values[0]; double[][] data = c.getData(); int row = -1; int col = -1; diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/graph/GatherNodesStream.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/graph/GatherNodesStream.java index 68a0e82e396..a6cde6685ab 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/graph/GatherNodesStream.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/graph/GatherNodesStream.java @@ -411,8 +411,7 @@ private StreamExpression toExpression(StreamFactory factory, boolean includeStre expression.addParameter( new StreamExpressionNamedParameter("maxDocFreq", Integer.toString(maxDocFreq))); } - if (tupleStream instanceof NodeStream) { - NodeStream nodeStream = (NodeStream) tupleStream; + if (tupleStream instanceof NodeStream nodeStream) { expression.addParameter( new StreamExpressionNamedParameter("walk", nodeStream.toString() + "->" + traverseTo)); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/BiJoinStream.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/BiJoinStream.java index ac8ec398233..566ed39f720 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/BiJoinStream.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/BiJoinStream.java @@ -91,10 +91,8 @@ private StreamComparator createIterationComparator(StreamEqualitor eq, StreamCom StreamEqualitor sourceEqualitor = ((MultipleFieldEqualitor) eq).getEqs()[idx]; StreamComparator sourceComparator = ((MultipleFieldComparator) comp).getComps()[idx]; - if (sourceEqualitor instanceof FieldEqualitor - && sourceComparator instanceof FieldComparator) { - FieldEqualitor fieldEqualitor = (FieldEqualitor) sourceEqualitor; - FieldComparator fieldComparator = (FieldComparator) sourceComparator; + if (sourceEqualitor instanceof FieldEqualitor fieldEqualitor + && sourceComparator instanceof FieldComparator fieldComparator) { compoundComps[idx] = new FieldComparator( fieldEqualitor.getLeftFieldName(), @@ -109,10 +107,8 @@ private StreamComparator createIterationComparator(StreamEqualitor eq, StreamCom StreamEqualitor sourceEqualitor = eq; StreamComparator sourceComparator = ((MultipleFieldComparator) comp).getComps()[0]; - if (sourceEqualitor instanceof FieldEqualitor - && sourceComparator instanceof FieldComparator) { - FieldEqualitor fieldEqualitor = (FieldEqualitor) sourceEqualitor; - FieldComparator fieldComparator = (FieldComparator) sourceComparator; + if (sourceEqualitor instanceof FieldEqualitor fieldEqualitor + && sourceComparator instanceof FieldComparator fieldComparator) { return new FieldComparator( fieldEqualitor.getLeftFieldName(), fieldEqualitor.getRightFieldName(), @@ -124,10 +120,8 @@ private StreamComparator createIterationComparator(StreamEqualitor eq, StreamCom StreamEqualitor sourceEqualitor = eq; StreamComparator sourceComparator = comp; - if (sourceEqualitor instanceof FieldEqualitor - && sourceComparator instanceof FieldComparator) { - FieldEqualitor fieldEqualitor = (FieldEqualitor) sourceEqualitor; - FieldComparator fieldComparator = (FieldComparator) sourceComparator; + if (sourceEqualitor instanceof FieldEqualitor fieldEqualitor + && sourceComparator instanceof FieldComparator fieldComparator) { return new FieldComparator( fieldEqualitor.getLeftFieldName(), fieldEqualitor.getRightFieldName(), @@ -148,8 +142,7 @@ private StreamComparator createSideComparator(StreamEqualitor eq, StreamComparat for (int idx = 0; idx < compoundComps.length; ++idx) { StreamComparator sourceComparator = ((MultipleFieldComparator) comp).getComps()[idx]; - if (sourceComparator instanceof FieldComparator) { - FieldComparator fieldComparator = (FieldComparator) sourceComparator; + if (sourceComparator instanceof FieldComparator fieldComparator) { compoundComps[idx] = new FieldComparator( fieldComparator.getLeftFieldName(), @@ -163,8 +156,7 @@ private StreamComparator createSideComparator(StreamEqualitor eq, StreamComparat } else if (comp instanceof MultipleFieldComparator) { StreamComparator sourceComparator = ((MultipleFieldComparator) comp).getComps()[0]; - if (sourceComparator instanceof FieldComparator) { - FieldComparator fieldComparator = (FieldComparator) sourceComparator; + if (sourceComparator instanceof FieldComparator fieldComparator) { return new FieldComparator( fieldComparator.getLeftFieldName(), fieldComparator.getRightFieldName(), @@ -175,8 +167,7 @@ private StreamComparator createSideComparator(StreamEqualitor eq, StreamComparat } else { StreamComparator sourceComparator = comp; - if (sourceComparator instanceof FieldComparator) { - FieldComparator fieldComparator = (FieldComparator) sourceComparator; + if (sourceComparator instanceof FieldComparator fieldComparator) { return new FieldComparator( fieldComparator.getLeftFieldName(), fieldComparator.getRightFieldName(), diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/HashRollupStream.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/HashRollupStream.java index adacba5578d..fa540ba0882 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/HashRollupStream.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/HashRollupStream.java @@ -117,8 +117,7 @@ private List flattenEqualitor(StreamEqualitor equalitor) { if (equalitor instanceof FieldEqualitor) { flattenedList.add((FieldEqualitor) equalitor); - } else if (equalitor instanceof MultipleFieldEqualitor) { - MultipleFieldEqualitor mEqualitor = (MultipleFieldEqualitor) equalitor; + } else if (equalitor instanceof MultipleFieldEqualitor mEqualitor) { for (StreamEqualitor subEqualitor : mEqualitor.getEqs()) { flattenedList.addAll(flattenEqualitor(subEqualitor)); } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/JDBCStream.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/JDBCStream.java index 920aa819d75..0252212fbb4 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/JDBCStream.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/JDBCStream.java @@ -406,8 +406,7 @@ public Object selectValue(ResultSet resultSet) throws SQLException { if (resultSet.wasNull()) { return null; } - if (obj instanceof String) { - String s = (String) obj; + if (obj instanceof String s) { if (s.contains(sep)) { s = s.substring(1); return s.split(sep); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/LetStream.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/LetStream.java index fc26a8972f7..be95e2271a3 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/LetStream.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/LetStream.java @@ -173,9 +173,8 @@ public void open() throws IOException { for (Map.Entry entry : entries) { String name = entry.getKey(); Object o = entry.getValue(); - if (o instanceof TupleStream) { + if (o instanceof TupleStream tStream) { List tuples = new ArrayList<>(); - TupleStream tStream = (TupleStream) o; tStream.setStreamContext(streamContext); try { tStream.open(); @@ -192,12 +191,11 @@ public void open() throws IOException { } finally { tStream.close(); } - } else if (o instanceof StreamEvaluator) { + } else if (o instanceof StreamEvaluator evaluator) { // Add the data from the StreamContext to a tuple. // Let the evaluator works from this tuple. // This will allow columns to be created from tuples already in the StreamContext. Tuple eTuple = new Tuple(lets); - StreamEvaluator evaluator = (StreamEvaluator) o; evaluator.setStreamContext(streamContext); Object eo = evaluator.evaluate(eTuple); if (evaluator instanceof MemsetEvaluator) { diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/ReducerStream.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/ReducerStream.java index 75d185d29bf..5ceaac33632 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/ReducerStream.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/ReducerStream.java @@ -75,8 +75,7 @@ public ReducerStream(TupleStream stream, StreamComparator comp, ReduceOperation } private StreamEqualitor convertToEqualitor(StreamComparator comp) { - if (comp instanceof MultipleFieldComparator) { - MultipleFieldComparator mComp = (MultipleFieldComparator) comp; + if (comp instanceof MultipleFieldComparator mComp) { StreamEqualitor[] eqs = new StreamEqualitor[mComp.getComps().length]; for (int idx = 0; idx < mComp.getComps().length; ++idx) { eqs[idx] = convertToEqualitor(mComp.getComps()[idx]); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/RollupStream.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/RollupStream.java index 91eb8771ceb..271ace0de6b 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/RollupStream.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/RollupStream.java @@ -119,8 +119,7 @@ private List flattenEqualitor(StreamEqualitor equalitor) { if (equalitor instanceof FieldEqualitor) { flattenedList.add((FieldEqualitor) equalitor); - } else if (equalitor instanceof MultipleFieldEqualitor) { - MultipleFieldEqualitor mEqualitor = (MultipleFieldEqualitor) equalitor; + } else if (equalitor instanceof MultipleFieldEqualitor mEqualitor) { for (StreamEqualitor subEqualitor : mEqualitor.getEqs()) { flattenedList.addAll(flattenEqualitor(subEqualitor)); } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/ScoreNodesStream.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/ScoreNodesStream.java index 01be8e309c4..9f0d083a308 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/ScoreNodesStream.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/ScoreNodesStream.java @@ -109,8 +109,7 @@ public ScoreNodesStream(StreamExpression expression, StreamFactory factory) thro private void init(TupleStream tupleStream, String termFreq) throws IOException { this.stream = tupleStream; this.termFreq = termFreq; - if (stream instanceof FacetStream) { - FacetStream facetStream = (FacetStream) stream; + if (stream instanceof FacetStream facetStream) { if (facetStream.getBuckets().length != 1) { throw new IOException( diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/TupStream.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/TupStream.java index 9b07be811e3..c0831e55c0a 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/TupStream.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/TupStream.java @@ -229,8 +229,7 @@ public void open() throws IOException { for (Object o : values.values()) { if (o instanceof Tuple) { unnestedTuple = (Tuple) o; - } else if (o instanceof List) { - List l = (List) o; + } else if (o instanceof List l) { if (l.size() > 0 && l.get(0) instanceof Tuple) { @SuppressWarnings({"unchecked"}) List tl = (List) l; diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/ZplotStream.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/ZplotStream.java index a994c55e646..c064bbae1a7 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/ZplotStream.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/ZplotStream.java @@ -152,13 +152,11 @@ public void open() throws IOException { } Object o = entry.getValue(); - if (o instanceof StreamEvaluator) { + if (o instanceof StreamEvaluator evaluator) { Tuple eTuple = new Tuple(lets); - StreamEvaluator evaluator = (StreamEvaluator) o; evaluator.setStreamContext(streamContext); Object eo = evaluator.evaluate(eTuple); - if (eo instanceof List) { - List l = (List) eo; + if (eo instanceof List l) { if (numTuples == -1) { numTuples = l.size(); } else { @@ -175,8 +173,7 @@ public void open() throws IOException { } } else { Object eval = lets.get(o); - if (eval instanceof List) { - List l = (List) eval; + if (eval instanceof List l) { if (numTuples == -1) { numTuples = l.size(); } else { @@ -223,8 +220,7 @@ public void open() throws IOException { } } else if (clusters) { Object o = evaluated.get("clusters"); - if (o instanceof KmeansEvaluator.ClusterTuple) { - KmeansEvaluator.ClusterTuple ct = (KmeansEvaluator.ClusterTuple) o; + if (o instanceof KmeansEvaluator.ClusterTuple ct) { List> cs = ct.getClusters(); int clusterNum = 0; for (CentroidCluster c : cs) { @@ -238,8 +234,7 @@ public void open() throws IOException { outTuples.add(tuple); } } - } else if (o instanceof DbscanEvaluator.ClusterTuple) { - DbscanEvaluator.ClusterTuple ct = (DbscanEvaluator.ClusterTuple) o; + } else if (o instanceof DbscanEvaluator.ClusterTuple ct) { List> cs = ct.getClusters(); int clusterNum = 0; for (Cluster c : cs) { @@ -256,11 +251,9 @@ public void open() throws IOException { } } else if (distribution) { Object o = evaluated.get("dist"); - if (o instanceof RealDistribution) { - RealDistribution realDistribution = (RealDistribution) o; + if (o instanceof RealDistribution realDistribution) { List binStats = null; - if (realDistribution instanceof EmpiricalDistribution) { - EmpiricalDistribution empiricalDistribution = (EmpiricalDistribution) realDistribution; + if (realDistribution instanceof EmpiricalDistribution empiricalDistribution) { binStats = empiricalDistribution.getBinStats(); } else { double[] samples = realDistribution.sample(500000); @@ -288,8 +281,7 @@ public void open() throws IOException { outTuples.add(tuple); } } - } else if (o instanceof IntegerDistribution) { - IntegerDistribution integerDistribution = (IntegerDistribution) o; + } else if (o instanceof IntegerDistribution integerDistribution) { int[] samples = integerDistribution.sample(50000); Frequency frequency = new Frequency(); for (int i : samples) { @@ -314,8 +306,7 @@ public void open() throws IOException { tuple.put("y", y[i]); outTuples.add(tuple); } - } else if (o instanceof List) { - List list = (List) o; + } else if (o instanceof List list) { if (list.get(0) instanceof Tuple) { @SuppressWarnings({"unchecked"}) List tlist = (List) o; @@ -340,8 +331,7 @@ public void open() throws IOException { } else if (table) { // Handle the Tuple and List of Tuples Object o = evaluated.get("table"); - if (o instanceof Matrix) { - Matrix m = (Matrix) o; + if (o instanceof Matrix m) { List rowLabels = m.getRowLabels(); List colLabels = m.getColumnLabels(); double[][] data = m.getData(); @@ -371,8 +361,7 @@ public void open() throws IOException { } else if (heat) { // Handle the Tuple and List of Tuples Object o = evaluated.get("heat"); - if (o instanceof Matrix) { - Matrix m = (Matrix) o; + if (o instanceof Matrix m) { List rowLabels = m.getRowLabels(); List colLabels = m.getColumnLabels(); double[][] data = m.getData(); diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/expr/StreamExpression.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/expr/StreamExpression.java index f9d2efbe844..77fbb57c6d0 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/expr/StreamExpression.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/expr/StreamExpression.java @@ -99,12 +99,10 @@ public String toString() { @Override public boolean equals(Object other) { - if (!(other instanceof StreamExpression)) { + if (!(other instanceof StreamExpression check)) { return false; } - StreamExpression check = (StreamExpression) other; - if (null == this.functionName && null != check.functionName) { return false; } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/expr/StreamExpressionNamedParameter.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/expr/StreamExpressionNamedParameter.java index 6c92b1c100d..148a018b754 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/expr/StreamExpressionNamedParameter.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/expr/StreamExpressionNamedParameter.java @@ -96,12 +96,10 @@ public String toString() { @Override public boolean equals(Object other) { - if (!(other instanceof StreamExpressionNamedParameter)) { + if (!(other instanceof StreamExpressionNamedParameter check)) { return false; } - StreamExpressionNamedParameter check = (StreamExpressionNamedParameter) other; - if (null == this.name && null != check.name) { return false; } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/expr/StreamExpressionValue.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/expr/StreamExpressionValue.java index dffa00e47db..d849d700360 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/expr/StreamExpressionValue.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/expr/StreamExpressionValue.java @@ -47,12 +47,10 @@ public String toString() { @Override public boolean equals(Object other) { - if (!(other instanceof StreamExpressionValue)) { + if (!(other instanceof StreamExpressionValue check)) { return false; } - StreamExpressionValue check = (StreamExpressionValue) other; - if (null == this.value && null == check.value) { return true; } @@ -60,7 +58,7 @@ public boolean equals(Object other) { return false; } - return this.value.equals(((StreamExpressionValue) other).value); + return this.value.equals(check.value); } @Override diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/MaxMetric.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/MaxMetric.java index 20958de16f2..b550776e281 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/MaxMetric.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/MaxMetric.java @@ -82,14 +82,12 @@ public void update(Tuple tuple) { if (d > doubleMax) { doubleMax = d; } - } else if (o instanceof Float) { - Float f = (Float) o; + } else if (o instanceof Float f) { double d = f.doubleValue(); if (d > doubleMax) { doubleMax = d; } - } else if (o instanceof Integer) { - Integer i = (Integer) o; + } else if (o instanceof Integer i) { long l = i.longValue(); if (l > longMax) { longMax = l; diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/MeanMetric.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/MeanMetric.java index 44eb2119b60..75bf9bfccd2 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/MeanMetric.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/MeanMetric.java @@ -78,17 +78,13 @@ private void init(String functionName, String columnName, boolean outputLong) { public void update(Tuple tuple) { ++count; Object o = tuple.get(columnName); - if (o instanceof Double) { - Double d = (Double) o; + if (o instanceof Double d) { doubleSum += d; - } else if (o instanceof Float) { - Float f = (Float) o; + } else if (o instanceof Float f) { doubleSum += f.doubleValue(); - } else if (o instanceof Integer) { - Integer i = (Integer) o; + } else if (o instanceof Integer i) { longSum += i.longValue(); - } else if (o instanceof Long) { - Long l = (Long) o; + } else if (o instanceof Long l) { longSum += l; } } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/MinMetric.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/MinMetric.java index a36c5b5768c..55e919475ce 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/MinMetric.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/MinMetric.java @@ -83,14 +83,12 @@ public void update(Tuple tuple) { if (d < doubleMin) { doubleMin = d; } - } else if (o instanceof Float) { - Float f = (Float) o; + } else if (o instanceof Float f) { double d = f.doubleValue(); if (d < doubleMin) { doubleMin = d; } - } else if (o instanceof Integer) { - Integer i = (Integer) o; + } else if (o instanceof Integer i) { long l = i.longValue(); if (l < longMin) { longMin = l; diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/SumMetric.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/SumMetric.java index 61d533a0dfd..dc16585425d 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/SumMetric.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/SumMetric.java @@ -68,17 +68,13 @@ public String[] getColumns() { @Override public void update(Tuple tuple) { Object o = tuple.get(columnName); - if (o instanceof Double) { - Double d = (Double) o; + if (o instanceof Double d) { doubleSum += d; - } else if (o instanceof Float) { - Float f = (Float) o; + } else if (o instanceof Float f) { doubleSum += f.doubleValue(); - } else if (o instanceof Integer) { - Integer i = (Integer) o; + } else if (o instanceof Integer i) { longSum += i.longValue(); - } else if (o instanceof Long) { - Long l = (Long) o; + } else if (o instanceof Long l) { longSum += l; } } diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/WeightedSumMetric.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/WeightedSumMetric.java index 62a5625f7f2..472f7a1ba8b 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/WeightedSumMetric.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/metrics/WeightedSumMetric.java @@ -80,12 +80,10 @@ private void init(String valueCol, String countCol, boolean outputLong) { public void update(Tuple tuple) { Object c = tuple.get(countCol); Object o = tuple.get(valueCol); - if (c instanceof Number && o instanceof Number) { + if (c instanceof Number count && o instanceof Number value) { if (parts == null) { parts = new ArrayList<>(); } - Number count = (Number) c; - Number value = (Number) o; parts.add(new Part(count.longValue(), value.doubleValue())); } } diff --git a/solr/solrj-zookeeper/src/java/org/apache/solr/client/solrj/cloud/VersionedData.java b/solr/solrj-zookeeper/src/java/org/apache/solr/client/solrj/cloud/VersionedData.java index 7a36d4578d1..a69a245845a 100644 --- a/solr/solrj-zookeeper/src/java/org/apache/solr/client/solrj/cloud/VersionedData.java +++ b/solr/solrj-zookeeper/src/java/org/apache/solr/client/solrj/cloud/VersionedData.java @@ -82,8 +82,7 @@ public String toString() { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof VersionedData)) return false; - VersionedData that = (VersionedData) o; + if (!(o instanceof VersionedData that)) return false; return version == that.version && Arrays.equals(data, that.data) && Objects.equals(owner, that.owner) diff --git a/solr/solrj-zookeeper/src/java/org/apache/solr/client/solrj/impl/NodeValueFetcher.java b/solr/solrj-zookeeper/src/java/org/apache/solr/client/solrj/impl/NodeValueFetcher.java index 56ec552723d..b2843c6dec5 100644 --- a/solr/solrj-zookeeper/src/java/org/apache/solr/client/solrj/impl/NodeValueFetcher.java +++ b/solr/solrj-zookeeper/src/java/org/apache/solr/client/solrj/impl/NodeValueFetcher.java @@ -93,8 +93,7 @@ public Object extractResult(Object root) { public Object convertVal(Object val) { if (val instanceof String) { return Double.valueOf((String) val); - } else if (val instanceof Number) { - Number num = (Number) val; + } else if (val instanceof Number num) { return num.doubleValue(); } else { diff --git a/solr/solrj-zookeeper/src/java/org/apache/solr/common/cloud/ZkStateReader.java b/solr/solrj-zookeeper/src/java/org/apache/solr/common/cloud/ZkStateReader.java index ff559e5f84b..efc22111abb 100644 --- a/solr/solrj-zookeeper/src/java/org/apache/solr/common/cloud/ZkStateReader.java +++ b/solr/solrj-zookeeper/src/java/org/apache/solr/common/cloud/ZkStateReader.java @@ -2118,9 +2118,7 @@ public int hashCode() { @Override public boolean equals(Object other) { - if (other instanceof DocCollectionAndLiveNodesWatcherWrapper) { - DocCollectionAndLiveNodesWatcherWrapper that = - (DocCollectionAndLiveNodesWatcherWrapper) other; + if (other instanceof DocCollectionAndLiveNodesWatcherWrapper that) { return this.collectionName.equals(that.collectionName) && this.delegate.equals(that.delegate); } diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/SolrQuery.java b/solr/solrj/src/java/org/apache/solr/client/solrj/SolrQuery.java index d82f46a399a..76b053a0824 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/SolrQuery.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/SolrQuery.java @@ -1362,8 +1362,7 @@ public ORDER getOrder() { @Override public boolean equals(Object other) { if (this == other) return true; - if (!(other instanceof SortClause)) return false; - final SortClause that = (SortClause) other; + if (!(other instanceof SortClause that)) return false; return this.getItem().equals(that.getItem()) && this.getOrder().equals(that.getOrder()); } diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/beans/DocumentObjectBinder.java b/solr/solrj/src/java/org/apache/solr/client/solrj/beans/DocumentObjectBinder.java index 0fac1f7ab03..11eea9d10e2 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/beans/DocumentObjectBinder.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/beans/DocumentObjectBinder.java @@ -112,8 +112,7 @@ public SolrInputDocument toSolrInputDocument(Object obj) { private void addChild(Object obj, DocField field, SolrInputDocument doc) { Object val = field.get(obj); if (val == null) return; - if (val instanceof Collection) { - Collection collection = (Collection) val; + if (val instanceof Collection collection) { for (Object o : collection) { SolrInputDocument child = toSolrInputDocument(o); doc.addChildDocument(child); @@ -285,9 +284,8 @@ private void storeType() { // assigned a default type type = Object.class; if (field != null) { - if (field.getGenericType() instanceof ParameterizedType) { + if (field.getGenericType() instanceof ParameterizedType parameterizedType) { // check what are the generic values - ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType(); Type[] types = parameterizedType.getActualTypeArguments(); if (types != null && types.length == 2 && types[0] == String.class) { // the key should always be String diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/BinaryRequestWriter.java b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/BinaryRequestWriter.java index 0dcdba37599..3176b9ce148 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/BinaryRequestWriter.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/BinaryRequestWriter.java @@ -37,8 +37,7 @@ public class BinaryRequestWriter extends RequestWriter { @Override public ContentWriter getContentWriter(SolrRequest req) { - if (req instanceof UpdateRequest) { - UpdateRequest updateRequest = (UpdateRequest) req; + if (req instanceof UpdateRequest updateRequest) { if (isEmpty(updateRequest)) return null; return new ContentWriter() { @Override @@ -58,8 +57,7 @@ public String getContentType() { @Override public Collection getContentStreams(SolrRequest req) throws IOException { - if (req instanceof UpdateRequest) { - UpdateRequest updateRequest = (UpdateRequest) req; + if (req instanceof UpdateRequest updateRequest) { if (isEmpty(updateRequest)) return null; throw new RuntimeException("This Should not happen"); } else { @@ -74,8 +72,7 @@ public String getUpdateContentType() { @Override public void write(SolrRequest request, OutputStream os) throws IOException { - if (request instanceof UpdateRequest) { - UpdateRequest updateRequest = (UpdateRequest) request; + if (request instanceof UpdateRequest updateRequest) { new JavaBinUpdateRequestCodec().marshal(updateRequest, os); } } diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/CloudHttp2SolrClient.java b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/CloudHttp2SolrClient.java index 523c46b844c..ade1ebe433f 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/CloudHttp2SolrClient.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/CloudHttp2SolrClient.java @@ -101,8 +101,7 @@ private ClusterStateProvider createZkClusterStateProvider(Builder builder) { ClusterStateProvider stateProvider = ClusterStateProvider.newZkClusterStateProvider( builder.zkHosts, builder.zkChroot, builder.canUseZkACLs); - if (stateProvider instanceof SolrZkClientTimeoutAware) { - var timeoutAware = (SolrZkClientTimeoutAware) stateProvider; + if (stateProvider instanceof SolrZkClientTimeoutAware timeoutAware) { timeoutAware.setZkClientTimeout(builder.zkClientTimeout); timeoutAware.setZkConnectTimeout(builder.zkConnectTimeout); } diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/CloudLegacySolrClient.java b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/CloudLegacySolrClient.java index 224757200ff..c8cce36fbf0 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/CloudLegacySolrClient.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/CloudLegacySolrClient.java @@ -380,8 +380,7 @@ public CloudLegacySolrClient build() { } else if (!zkHosts.isEmpty()) { this.stateProvider = ClusterStateProvider.newZkClusterStateProvider(zkHosts, zkChroot, canUseZkACLs); - if (stateProvider instanceof SolrZkClientTimeoutAware) { - var timeoutAware = (SolrZkClientTimeoutAware) stateProvider; + if (stateProvider instanceof SolrZkClientTimeoutAware timeoutAware) { timeoutAware.setZkClientTimeout(zkClientTimeout); timeoutAware.setZkConnectTimeout(zkConnectTimeout); } diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/CloudSolrClient.java b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/CloudSolrClient.java index 38cd77ddc4e..5f3b4cab9d4 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/CloudSolrClient.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/CloudSolrClient.java @@ -453,8 +453,7 @@ private NamedList directUpdate(AbstractUpdateRequest request, String col if (exceptions.size() > 0) { Throwable firstException = exceptions.getVal(0); - if (firstException instanceof SolrException) { - SolrException e = (SolrException) firstException; + if (firstException instanceof SolrException e) { throw getRouteException( SolrException.ErrorCode.getErrorCode(e.code()), exceptions, routes); } else { @@ -611,8 +610,7 @@ protected > T condenseResponse( status = s; } Object rfObj = header.get(UpdateRequest.REPFACT); - if (rfObj != null && rfObj instanceof Integer) { - Integer routeRf = (Integer) rfObj; + if (rfObj != null && rfObj instanceof Integer routeRf) { if (rf == null || routeRf < rf) rf = routeRf; } @@ -639,10 +637,9 @@ protected > T condenseResponse( } for (String updateType : Arrays.asList("adds", "deletes", "deleteByQuery")) { Object obj = shardResponse.get(updateType); - if (obj instanceof NamedList) { + if (obj instanceof NamedList nl) { NamedList versionsList = versions.containsKey(updateType) ? versions.get(updateType) : new NamedList<>(); - NamedList nl = (NamedList) obj; versionsList.addAll(nl); versions.put(updateType, versionsList); } @@ -732,8 +729,7 @@ public RouteException( NamedList metadata = new NamedList(); for (int i = 0; i < throwables.size(); i++) { Throwable t = throwables.getVal(i); - if (t instanceof SolrException) { - SolrException e = (SolrException) t; + if (t instanceof SolrException e) { NamedList eMeta = e.getMetadata(); if (null != eMeta) { metadata.addAll(eMeta); @@ -825,8 +821,7 @@ protected NamedList requestWithRetryOnStaleState( } } - if (request.getParams() instanceof ModifiableSolrParams) { - ModifiableSolrParams params = (ModifiableSolrParams) request.getParams(); + if (request.getParams() instanceof ModifiableSolrParams params) { if (stateVerParam != null) { params.set(STATE_VERSION, stateVerParam); } else { @@ -840,11 +835,10 @@ protected NamedList requestWithRetryOnStaleState( // to avoid an O(n) operation we always add STATE_VERSION to the last and try to read it from // there Object o = resp == null || resp.size() == 0 ? null : resp.get(STATE_VERSION, resp.size() - 1); - if (o != null && o instanceof Map) { + if (o != null && o instanceof Map invalidStates) { // remove this because no one else needs this and tests would fail if they are comparing // responses resp.remove(resp.size() - 1); - Map invalidStates = (Map) o; for (Map.Entry e : invalidStates.entrySet()) { getDocCollection((String) e.getKey(), (Integer) e.getValue()); } diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/ConcurrentUpdateHttp2SolrClient.java b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/ConcurrentUpdateHttp2SolrClient.java index 7b44264f995..dcbaff0a832 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/ConcurrentUpdateHttp2SolrClient.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/ConcurrentUpdateHttp2SolrClient.java @@ -362,10 +362,9 @@ public NamedList request(final SolrRequest request, String collection ClientUtils.shouldApplyDefaultCollection(collection, request) ? defaultCollection : collection; - if (!(request instanceof UpdateRequest)) { + if (!(request instanceof UpdateRequest req)) { return client.requestWithBaseUrl(basePath, (c) -> c.request(request, effectiveCollection)); } - UpdateRequest req = (UpdateRequest) request; // this happens for commit... if (streamDeletes) { if ((req.getDocuments() == null || req.getDocuments().isEmpty()) diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/ConcurrentUpdateSolrClient.java b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/ConcurrentUpdateSolrClient.java index f48ba05a0c8..0911b1c0a18 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/ConcurrentUpdateSolrClient.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/ConcurrentUpdateSolrClient.java @@ -488,10 +488,9 @@ public NamedList request(final SolrRequest request, String collection throws SolrServerException, IOException { if (ClientUtils.shouldApplyDefaultCollection(collection, request)) collection = defaultCollection; - if (!(request instanceof UpdateRequest)) { + if (!(request instanceof UpdateRequest req)) { return client.request(request, collection); } - UpdateRequest req = (UpdateRequest) request; // this happens for commit... if (streamDeletes) { diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/Krb5HttpClientBuilder.java b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/Krb5HttpClientBuilder.java index 8b47d45d2f0..0355c1a1b75 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/Krb5HttpClientBuilder.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/Krb5HttpClientBuilder.java @@ -217,8 +217,7 @@ public Principal getUserPrincipal() { // Set a buffered entity based request interceptor private HttpRequestInterceptor bufferedEntityInterceptor = (request, context) -> { - if (request instanceof HttpEntityEnclosingRequest) { - HttpEntityEnclosingRequest enclosingRequest = ((HttpEntityEnclosingRequest) request); + if (request instanceof HttpEntityEnclosingRequest enclosingRequest) { HttpEntity requestEntity = enclosingRequest.getEntity(); enclosingRequest.setEntity(new BufferedHttpEntity(requestEntity)); } diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/LBSolrClient.java b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/LBSolrClient.java index 6e691b802f0..2a0e03e4a3e 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/impl/LBSolrClient.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/impl/LBSolrClient.java @@ -173,8 +173,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { if (this == obj) return true; - if (!(obj instanceof Endpoint)) return false; - final Endpoint rhs = (Endpoint) obj; + if (!(obj instanceof Endpoint rhs)) return false; return Objects.equals(baseUrl, rhs.baseUrl) && Objects.equals(core, rhs.core); } @@ -497,8 +496,7 @@ private NamedList doRequest( // Some implementations of LBSolrClient.getClient(...) return a Http2SolrClient that may not be // pointed at the desired URL (or any URL for that matter). We special case that here to ensure // the appropriate URL is provided. - if (solrClient instanceof Http2SolrClient) { - final var httpSolrClient = (Http2SolrClient) solrClient; + if (solrClient instanceof Http2SolrClient httpSolrClient) { return httpSolrClient.requestWithBaseUrl(baseUrl, (c) -> c.request(solrRequest, collection)); } else if (solrClient instanceof HttpJdkSolrClient) { return ((HttpJdkSolrClient) solrClient).requestWithBaseUrl(baseUrl, solrRequest, collection); diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/request/JavaBinUpdateRequestCodec.java b/solr/solrj/src/java/org/apache/solr/client/solrj/request/JavaBinUpdateRequestCodec.java index a2423a788c2..07e4ce48d35 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/request/JavaBinUpdateRequestCodec.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/request/JavaBinUpdateRequestCodec.java @@ -352,8 +352,7 @@ private SolrInputDocument convertMapToSolrInputDoc(Map m) { m.forEach( (k, v) -> { if (CHILDDOC.equals(k.toString())) { - if (v instanceof List) { - List list = (List) v; + if (v instanceof List list) { for (Object o : list) { if (o instanceof Map) { result.addChildDocument(convertMapToSolrInputDoc((Map) o)); diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/request/RequestWriter.java b/solr/solrj/src/java/org/apache/solr/client/solrj/request/RequestWriter.java index bfc7141648d..29bad435489 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/request/RequestWriter.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/request/RequestWriter.java @@ -51,8 +51,7 @@ public interface ContentWriter { * to do a pull write. */ public ContentWriter getContentWriter(SolrRequest req) { - if (req instanceof UpdateRequest) { - UpdateRequest updateRequest = (UpdateRequest) req; + if (req instanceof UpdateRequest updateRequest) { if (isEmpty(updateRequest)) return null; return new ContentWriter() { @Override @@ -90,8 +89,7 @@ && isNull(updateRequest.getDeleteQuery()) } public void write(SolrRequest request, OutputStream os) throws IOException { - if (request instanceof UpdateRequest) { - UpdateRequest updateRequest = (UpdateRequest) request; + if (request instanceof UpdateRequest updateRequest) { BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(os, StandardCharsets.UTF_8)); updateRequest.writeXML(writer); diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/request/V2Request.java b/solr/solrj/src/java/org/apache/solr/client/solrj/request/V2Request.java index bcef4488560..6e485c5a30d 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/request/V2Request.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/request/V2Request.java @@ -78,8 +78,7 @@ public RequestWriter.ContentWriter getContentWriter(String s) { return new RequestWriter.ContentWriter() { @Override public void write(OutputStream os) throws IOException { - if (payload instanceof ByteBuffer) { - ByteBuffer b = (ByteBuffer) payload; + if (payload instanceof ByteBuffer b) { os.write(b.array(), b.arrayOffset(), b.limit()); return; } diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/request/beans/PluginMeta.java b/solr/solrj/src/java/org/apache/solr/client/solrj/request/beans/PluginMeta.java index a0471f5fe9b..cddfb2606c0 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/request/beans/PluginMeta.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/request/beans/PluginMeta.java @@ -60,8 +60,7 @@ public void writeMap(EntryWriter ew) throws IOException { @Override public boolean equals(Object obj) { - if (obj instanceof PluginMeta) { - PluginMeta that = (PluginMeta) obj; + if (obj instanceof PluginMeta that) { return Objects.equals(this.name, that.name) && Objects.equals(this.klass, that.klass) && Objects.equals(this.version, that.version) diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/request/beans/RateLimiterPayload.java b/solr/solrj/src/java/org/apache/solr/client/solrj/request/beans/RateLimiterPayload.java index 07bae33de6b..e82d0789b5f 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/request/beans/RateLimiterPayload.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/request/beans/RateLimiterPayload.java @@ -47,8 +47,7 @@ public RateLimiterPayload copy() { @Override public boolean equals(Object obj) { - if (obj instanceof RateLimiterPayload) { - RateLimiterPayload that = (RateLimiterPayload) obj; + if (obj instanceof RateLimiterPayload that) { return Objects.equals(this.enabled, that.enabled) && Objects.equals(this.guaranteedSlots, that.guaranteedSlots) && Objects.equals(this.allowedRequests, that.allowedRequests) diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/response/QueryResponse.java b/solr/solrj/src/java/org/apache/solr/client/solrj/response/QueryResponse.java index 2a785632d24..e09a073f4d4 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/response/QueryResponse.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/response/QueryResponse.java @@ -382,8 +382,7 @@ private List extractRangeFacets(NamedList> rf) { Object rawGap = values.get("gap"); RangeFacet rangeFacet; - if (rawGap instanceof Number) { - Number gap = (Number) rawGap; + if (rawGap instanceof Number gap) { Number start = (Number) values.get("start"); Number end = (Number) values.get("end"); @@ -393,9 +392,7 @@ private List extractRangeFacets(NamedList> rf) { rangeFacet = new RangeFacet.Numeric(facet.getKey(), start, end, gap, before, after, between); - } else if (rawGap instanceof String && values.get("start") instanceof Date) { - String gap = (String) rawGap; - Date start = (Date) values.get("start"); + } else if (rawGap instanceof String gap && values.get("start") instanceof Date start) { Date end = (Date) values.get("end"); Number before = (Number) values.get("before"); diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/response/Suggestion.java b/solr/solrj/src/java/org/apache/solr/client/solrj/response/Suggestion.java index c84878357df..9aca4bf7319 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/response/Suggestion.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/response/Suggestion.java @@ -34,9 +34,7 @@ public Suggestion(String term, long weight, String payload) { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof Suggestion)) return false; - - Suggestion that = (Suggestion) o; + if (!(o instanceof Suggestion that)) return false; return payload.equals(that.payload) && term.equals(that.term); } diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/response/json/NestableJsonFacet.java b/solr/solrj/src/java/org/apache/solr/client/solrj/response/json/NestableJsonFacet.java index 9be73481432..761113729f5 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/response/json/NestableJsonFacet.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/response/json/NestableJsonFacet.java @@ -56,8 +56,8 @@ public NestableJsonFacet(NamedList facetNL) { || entry.getValue() instanceof Date) { // Stat/agg facet value statsByName.put(key, entry.getValue()); - } else if (entry.getValue() instanceof NamedList) { // Either heatmap/query/range/terms facet - final NamedList facet = (NamedList) entry.getValue(); + } else if (entry.getValue() + instanceof NamedList facet) { // Either heatmap/query/range/terms facet final boolean isBucketBased = facet.get("buckets") != null; final boolean isHeatmap = HeatmapJsonFacet.isHeatmapFacet(facet); if (isBucketBased) { diff --git a/solr/solrj/src/java/org/apache/solr/client/solrj/util/ClientUtils.java b/solr/solrj/src/java/org/apache/solr/client/solrj/util/ClientUtils.java index 0dab0c402aa..646ef546c99 100644 --- a/solr/solrj/src/java/org/apache/solr/client/solrj/util/ClientUtils.java +++ b/solr/solrj/src/java/org/apache/solr/client/solrj/util/ClientUtils.java @@ -122,8 +122,7 @@ public static void writeXML(SolrInputDocument doc, Writer writer) throws IOExcep for (Entry entry : ((Map) v).entrySet()) { update = entry.getKey().toString(); v = entry.getValue(); - if (v instanceof Collection) { - Collection values = (Collection) v; + if (v instanceof Collection values) { for (Object value : values) { writeVal(writer, name, value, update); } @@ -150,11 +149,9 @@ private static void writeVal(Writer writer, String name, Object v, String update throws IOException { if (v instanceof Date) { v = ((Date) v).toInstant().toString(); - } else if (v instanceof byte[]) { - byte[] bytes = (byte[]) v; + } else if (v instanceof byte[] bytes) { v = Base64.getEncoder().encodeToString(bytes); - } else if (v instanceof ByteBuffer) { - ByteBuffer bytes = (ByteBuffer) v; + } else if (v instanceof ByteBuffer bytes) { v = new String( Base64.getEncoder() @@ -168,8 +165,7 @@ private static void writeVal(Writer writer, String name, Object v, String update } XML.Writable valWriter = null; - if (v instanceof SolrInputDocument) { - final SolrInputDocument solrDoc = (SolrInputDocument) v; + if (v instanceof SolrInputDocument solrDoc) { valWriter = (writer1) -> writeXML(solrDoc, writer1); } else if (v != null) { final Object val = v; diff --git a/solr/solrj/src/java/org/apache/solr/common/EnumFieldValue.java b/solr/solrj/src/java/org/apache/solr/common/EnumFieldValue.java index ec61abe5845..9cfb1a285fa 100644 --- a/solr/solrj/src/java/org/apache/solr/common/EnumFieldValue.java +++ b/solr/solrj/src/java/org/apache/solr/common/EnumFieldValue.java @@ -42,9 +42,8 @@ public EnumFieldValue(Integer intValue, String stringValue) { @Override public boolean equals(Object obj) { if (obj == null) return false; - if (!(obj instanceof EnumFieldValue)) return false; + if (!(obj instanceof EnumFieldValue otherEnumFieldValue)) return false; - EnumFieldValue otherEnumFieldValue = (EnumFieldValue) obj; return equalsIntegers(intValue, otherEnumFieldValue.intValue) && equalStrings(stringValue, otherEnumFieldValue.stringValue); } diff --git a/solr/solrj/src/java/org/apache/solr/common/SolrDocument.java b/solr/solrj/src/java/org/apache/solr/common/SolrDocument.java index f9fc0393058..a0176d31dc0 100644 --- a/solr/solrj/src/java/org/apache/solr/common/SolrDocument.java +++ b/solr/solrj/src/java/org/apache/solr/common/SolrDocument.java @@ -166,8 +166,7 @@ public void addField(String name, Object value) { /** returns the first value for a field */ public Object getFirstValue(String name) { Object v = _fields.get(name); - if (v == null || !(v instanceof Collection)) return v; - Collection c = (Collection) v; + if (v == null || !(v instanceof Collection c)) return v; if (c.size() > 0) { return c.iterator().next(); } @@ -215,8 +214,7 @@ public void visitSelfAndNestedDocs(BiConsumer consumer) { final Object value = keyVal.getValue(); if (value instanceof SolrDocument) { consumer.accept(keyVal.getKey(), (SolrDocument) value); - } else if (value instanceof Collection) { - Collection cVal = (Collection) value; + } else if (value instanceof Collection cVal) { for (Object v : cVal) { if (v instanceof SolrDocument) { consumer.accept(keyVal.getKey(), (SolrDocument) v); diff --git a/solr/solrj/src/java/org/apache/solr/common/SolrException.java b/solr/solrj/src/java/org/apache/solr/common/SolrException.java index e19883539ff..80e28818a31 100644 --- a/solr/solrj/src/java/org/apache/solr/common/SolrException.java +++ b/solr/solrj/src/java/org/apache/solr/common/SolrException.java @@ -157,8 +157,7 @@ public static Throwable getRootCause(Throwable t) { * no-op. */ public static SolrException wrapLuceneTragicExceptionIfNecessary(Exception e) { - if (e instanceof SolrException) { - final SolrException solrException = (SolrException) e; + if (e instanceof SolrException solrException) { assert solrException.code() >= 500 && solrException.code() < 600; return solrException; } diff --git a/solr/solrj/src/java/org/apache/solr/common/SolrInputDocument.java b/solr/solrj/src/java/org/apache/solr/common/SolrInputDocument.java index 0b2886c0470..4ae3f35eff5 100644 --- a/solr/solrj/src/java/org/apache/solr/common/SolrInputDocument.java +++ b/solr/solrj/src/java/org/apache/solr/common/SolrInputDocument.java @@ -288,8 +288,7 @@ public void visitSelfAndNestedDocs(BiConsumer consume final Object value = field.getValue(); if (value instanceof SolrInputDocument) { consumer.accept(field.name, (SolrInputDocument) value); - } else if (value instanceof Collection) { - Collection cVal = (Collection) value; + } else if (value instanceof Collection cVal) { for (Object v : cVal) { if (v instanceof SolrInputDocument) { consumer.accept(field.name, (SolrInputDocument) v); diff --git a/solr/solrj/src/java/org/apache/solr/common/SolrInputField.java b/solr/solrj/src/java/org/apache/solr/common/SolrInputField.java index 4a2e7d1668e..281d9817d07 100644 --- a/solr/solrj/src/java/org/apache/solr/common/SolrInputField.java +++ b/solr/solrj/src/java/org/apache/solr/common/SolrInputField.java @@ -41,8 +41,7 @@ public SolrInputField(String n) { * then that collection will be used as the backing collection for the values. */ public void setValue(Object v) { - if (v instanceof Object[]) { - Object[] arr = (Object[]) v; + if (v instanceof Object[] arr) { Collection c = new ArrayList<>(arr.length); for (Object o : arr) { c.add(o); @@ -100,8 +99,7 @@ public void addValue(Object v) { // --------------------------------------------------------------- public Object getFirstValue() { - if (value instanceof Collection) { - Collection c = (Collection) value; + if (value instanceof Collection c) { if (c.size() > 0) { return c.iterator().next(); } diff --git a/solr/solrj/src/java/org/apache/solr/common/ToleratedUpdateError.java b/solr/solrj/src/java/org/apache/solr/common/ToleratedUpdateError.java index 20a9c07e574..15d03b4792b 100644 --- a/solr/solrj/src/java/org/apache/solr/common/ToleratedUpdateError.java +++ b/solr/solrj/src/java/org/apache/solr/common/ToleratedUpdateError.java @@ -193,8 +193,7 @@ public int hashCode() { @Override public boolean equals(Object o) { - if (o instanceof ToleratedUpdateError) { - ToleratedUpdateError that = (ToleratedUpdateError) o; + if (o instanceof ToleratedUpdateError that) { return that.type.equals(this.type) && that.id.equals(this.id) && that.message.equals(this.message); diff --git a/solr/solrj/src/java/org/apache/solr/common/cloud/ClusterState.java b/solr/solrj/src/java/org/apache/solr/common/cloud/ClusterState.java index f4945921821..19bfc2565d6 100644 --- a/solr/solrj/src/java/org/apache/solr/common/cloud/ClusterState.java +++ b/solr/solrj/src/java/org/apache/solr/common/cloud/ClusterState.java @@ -379,8 +379,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { if (this == obj) return true; - if (!(obj instanceof ClusterState)) return false; - ClusterState other = (ClusterState) obj; + if (!(obj instanceof ClusterState other)) return false; if (liveNodes == null) { return other.liveNodes == null; } else return liveNodes.equals(other.liveNodes); diff --git a/solr/solrj/src/java/org/apache/solr/common/cloud/DocCollection.java b/solr/solrj/src/java/org/apache/solr/common/cloud/DocCollection.java index 750a630b8d3..1bb0cd42d41 100644 --- a/solr/solrj/src/java/org/apache/solr/common/cloud/DocCollection.java +++ b/solr/solrj/src/java/org/apache/solr/common/cloud/DocCollection.java @@ -514,8 +514,7 @@ public String getShardId(String nodeName, String coreName) { @Override public boolean equals(Object that) { - if (!(that instanceof DocCollection)) return false; - DocCollection other = (DocCollection) that; + if (!(that instanceof DocCollection other)) return false; return super.equals(that) && Objects.equals(this.name, other.name) && this.znodeVersion == other.znodeVersion diff --git a/solr/solrj/src/java/org/apache/solr/common/cloud/DocRouter.java b/solr/solrj/src/java/org/apache/solr/common/cloud/DocRouter.java index 3c8ff93b816..2ac50b6b1f5 100644 --- a/solr/solrj/src/java/org/apache/solr/common/cloud/DocRouter.java +++ b/solr/solrj/src/java/org/apache/solr/common/cloud/DocRouter.java @@ -136,8 +136,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { - if (!(obj instanceof Range)) return false; - Range other = (Range) obj; + if (!(obj instanceof Range other)) return false; return this.min == other.min && this.max == other.max; } diff --git a/solr/solrj/src/java/org/apache/solr/common/cloud/PerReplicaStates.java b/solr/solrj/src/java/org/apache/solr/common/cloud/PerReplicaStates.java index 60616d8fd70..e8e95d4e8ea 100644 --- a/solr/solrj/src/java/org/apache/solr/common/cloud/PerReplicaStates.java +++ b/solr/solrj/src/java/org/apache/solr/common/cloud/PerReplicaStates.java @@ -291,8 +291,7 @@ public String toString() { @Override public boolean equals(Object o) { - if (o instanceof State) { - State that = (State) o; + if (o instanceof State that) { return Objects.equals(this.asString, that.asString); } return false; diff --git a/solr/solrj/src/java/org/apache/solr/common/cloud/Replica.java b/solr/solrj/src/java/org/apache/solr/common/cloud/Replica.java index e3dfa9dc209..bd526c4fda2 100644 --- a/solr/solrj/src/java/org/apache/solr/common/cloud/Replica.java +++ b/solr/solrj/src/java/org/apache/solr/common/cloud/Replica.java @@ -282,11 +282,9 @@ public Map getProperties() { @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof Replica)) return false; + if (!(o instanceof Replica other)) return false; if (!super.equals(o)) return false; - Replica other = (Replica) o; - return name.equals(other.name); } diff --git a/solr/solrj/src/java/org/apache/solr/common/cloud/Slice.java b/solr/solrj/src/java/org/apache/solr/common/cloud/Slice.java index f1998b4264e..99374dcb7af 100644 --- a/solr/solrj/src/java/org/apache/solr/common/cloud/Slice.java +++ b/solr/solrj/src/java/org/apache/solr/common/cloud/Slice.java @@ -206,8 +206,7 @@ public Slice( this.routingRules = new HashMap<>(); for (Map.Entry entry : rules.entrySet()) { Object o = entry.getValue(); - if (o instanceof Map) { - Map map = (Map) o; + if (o instanceof Map map) { RoutingRule rule = new RoutingRule(entry.getKey(), map); routingRules.put(entry.getKey(), rule); } else { diff --git a/solr/solrj/src/java/org/apache/solr/common/util/ByteArrayUtf8CharSequence.java b/solr/solrj/src/java/org/apache/solr/common/util/ByteArrayUtf8CharSequence.java index c4baf6326e8..052514e75c9 100644 --- a/solr/solrj/src/java/org/apache/solr/common/util/ByteArrayUtf8CharSequence.java +++ b/solr/solrj/src/java/org/apache/solr/common/util/ByteArrayUtf8CharSequence.java @@ -124,9 +124,8 @@ public int length() { public boolean equals(Object other) { if (other instanceof Utf8CharSequence) { if (size() != ((Utf8CharSequence) other).size()) return false; - if (other instanceof ByteArrayUtf8CharSequence) { - if (this.length != ((ByteArrayUtf8CharSequence) other).length) return false; - ByteArrayUtf8CharSequence that = (ByteArrayUtf8CharSequence) other; + if (other instanceof ByteArrayUtf8CharSequence that) { + if (this.length != that.length) return false; return _equals( this.buf, this.offset, diff --git a/solr/solrj/src/java/org/apache/solr/common/util/CommandOperation.java b/solr/solrj/src/java/org/apache/solr/common/util/CommandOperation.java index f19fc4c335a..37498dd4e84 100644 --- a/solr/solrj/src/java/org/apache/solr/common/util/CommandOperation.java +++ b/solr/solrj/src/java/org/apache/solr/common/util/CommandOperation.java @@ -101,8 +101,7 @@ private Object getMapVal(String key) { } return commandData; } - if (commandData instanceof Map) { - Map metaData = (Map) commandData; + if (commandData instanceof Map metaData) { return metaData.get(key); } else { String msg = " value has to be an object for operation :" + name; @@ -284,8 +283,7 @@ public static List parse(Reader rdr, Set singletonComm Object key = ob.getKey(); ev = parser.nextEvent(); Object val = ob.getVal(); - if (val instanceof List && !singletonCommands.contains(key)) { - List list = (List) val; + if (val instanceof List list && !singletonCommands.contains(key)) { for (Object o : list) { if (!(o instanceof Map)) { operations.add(new CommandOperation(String.valueOf(key), list)); @@ -371,8 +369,7 @@ public static List clone(List ops) { public Integer getInt(String name, Integer def) { Object o = getVal(name); if (o == null) return def; - if (o instanceof Number) { - Number number = (Number) o; + if (o instanceof Number number) { return number.intValue(); } else { try { diff --git a/solr/solrj/src/java/org/apache/solr/common/util/JavaBinCodec.java b/solr/solrj/src/java/org/apache/solr/common/util/JavaBinCodec.java index 9a16ea5abbc..77e7186c9de 100644 --- a/solr/solrj/src/java/org/apache/solr/common/util/JavaBinCodec.java +++ b/solr/solrj/src/java/org/apache/solr/common/util/JavaBinCodec.java @@ -887,8 +887,7 @@ public boolean equals(Object obj) { if (this == obj) { return true; } - if (obj instanceof Map.Entry) { - Entry entry = (Entry) obj; + if (obj instanceof Map.Entry entry) { return (this.getKey().equals(entry.getKey()) && this.getValue().equals(entry.getValue())); } return false; @@ -1096,8 +1095,7 @@ public boolean writePrimitive(Object val) throws IOException { } else if (val instanceof byte[]) { writeByteArray((byte[]) val, 0, ((byte[]) val).length); return true; - } else if (val instanceof ByteBuffer) { - ByteBuffer buf = (ByteBuffer) val; + } else if (val instanceof ByteBuffer buf) { writeByteArray(buf.array(), buf.arrayOffset() + buf.position(), buf.limit() - buf.position()); return true; } else if (val == END_OBJ) { diff --git a/solr/solrj/src/java/org/apache/solr/common/util/JsonSchemaValidator.java b/solr/solrj/src/java/org/apache/solr/common/util/JsonSchemaValidator.java index 391a36884a3..9988ff94c46 100644 --- a/solr/solrj/src/java/org/apache/solr/common/util/JsonSchemaValidator.java +++ b/solr/solrj/src/java/org/apache/solr/common/util/JsonSchemaValidator.java @@ -339,8 +339,7 @@ class OneOfValidator extends Validator> { @Override boolean validate(Object o, List errs) { - if (o instanceof Map) { - Map map = (Map) o; + if (o instanceof Map map) { for (Object key : map.keySet()) { if (oneOfProps.contains(key.toString())) return true; } diff --git a/solr/solrj/src/java/org/apache/solr/common/util/NamedList.java b/solr/solrj/src/java/org/apache/solr/common/util/NamedList.java index aef0edaa4cf..e443414c5b1 100644 --- a/solr/solrj/src/java/org/apache/solr/common/util/NamedList.java +++ b/solr/solrj/src/java/org/apache/solr/common/util/NamedList.java @@ -502,8 +502,7 @@ public Map asMap(int maxDepth) { } Object old = result.put(getName(i), val); if (old != null) { - if (old instanceof List) { - List list = (List) old; + if (old instanceof List list) { list.add(val); result.put(getName(i), old); } else { @@ -529,8 +528,7 @@ public SolrParams toSolrParams() { Object val = this.getVal(i); if (val instanceof String[]) { MultiMapSolrParams.addParam(name, (String[]) val, map); - } else if (val instanceof List) { - List l = (List) val; + } else if (val instanceof List l) { String[] s = new String[l.size()]; for (int j = 0; j < l.size(); j++) { s[j] = l.get(j) == null ? null : l.get(j).toString(); @@ -813,8 +811,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { - if (!(obj instanceof NamedList)) return false; - NamedList nl = (NamedList) obj; + if (!(obj instanceof NamedList nl)) return false; return this.nvPairs.equals(nl.nvPairs); } diff --git a/solr/solrj/src/java/org/apache/solr/common/util/TextWriter.java b/solr/solrj/src/java/org/apache/solr/common/util/TextWriter.java index 7c64954b31f..5edf9c2c99c 100644 --- a/solr/solrj/src/java/org/apache/solr/common/util/TextWriter.java +++ b/solr/solrj/src/java/org/apache/solr/common/util/TextWriter.java @@ -99,8 +99,7 @@ default void writeVal(String name, Object val, boolean raw) throws IOException { writeArray(name, ((Iterable) val).iterator(), raw); } else if (val instanceof Object[]) { writeArray(name, (Object[]) val, raw); - } else if (val instanceof byte[]) { - byte[] arr = (byte[]) val; + } else if (val instanceof byte[] arr) { writeByteArr(name, arr, 0, arr.length); } else if (val instanceof EnumFieldValue) { if (raw) { diff --git a/solr/solrj/src/java/org/apache/solr/common/util/Utils.java b/solr/solrj/src/java/org/apache/solr/common/util/Utils.java index 7102ab75598..618217583a7 100644 --- a/solr/solrj/src/java/org/apache/solr/common/util/Utils.java +++ b/solr/solrj/src/java/org/apache/solr/common/util/Utils.java @@ -165,8 +165,7 @@ public static void forEachMapEntry( @SuppressWarnings({"unchecked"}) public static void forEachMapEntry(Object o, @SuppressWarnings({"rawtypes"}) BiConsumer fun) { - if (o instanceof MapWriter) { - MapWriter m = (MapWriter) o; + if (o instanceof MapWriter m) { try { m.writeMap( new MapWriter.EntryWriter() { @@ -530,8 +529,7 @@ public static Object getObjectByPath(Object root, boolean onlyPrimitive, List -1) { - if (o instanceof List) { - List l = (List) o; + if (o instanceof List l) { o = idx < l.size() ? l.get(idx) : null; } else if (o instanceof IteratorWriter) { o = getValueAt((IteratorWriter) o, idx); diff --git a/solr/solrj/src/java/org/apache/solr/common/util/ValidatingJsonMap.java b/solr/solrj/src/java/org/apache/solr/common/util/ValidatingJsonMap.java index bd678bf5161..09fe360cbbe 100644 --- a/solr/solrj/src/java/org/apache/solr/common/util/ValidatingJsonMap.java +++ b/solr/solrj/src/java/org/apache/solr/common/util/ValidatingJsonMap.java @@ -53,8 +53,7 @@ public class ValidatingJsonMap implements Map, NavigableObject { @SuppressWarnings({"rawtypes"}) public static final PredicateWithErrMsg ENUM_OF = pair -> { - if (pair.second() instanceof Set) { - Set set = (Set) pair.second(); + if (pair.second() instanceof Set set) { if (pair.first() instanceof Collection) { for (Object o : (Collection) pair.first()) { if (!set.contains(o)) { diff --git a/solr/solrj/src/test/org/apache/solr/client/solrj/SolrExampleCborTest.java b/solr/solrj/src/test/org/apache/solr/client/solrj/SolrExampleCborTest.java index 41cfd596fed..d1c5835befd 100644 --- a/solr/solrj/src/test/org/apache/solr/client/solrj/SolrExampleCborTest.java +++ b/solr/solrj/src/test/org/apache/solr/client/solrj/SolrExampleCborTest.java @@ -245,8 +245,7 @@ private static RequestWriter cborRequestWriter() { @Override public ContentWriter getContentWriter(SolrRequest request) { - if (request instanceof UpdateRequest) { - UpdateRequest updateRequest = (UpdateRequest) request; + if (request instanceof UpdateRequest updateRequest) { List docs = updateRequest.getDocuments(); if (docs == null || docs.isEmpty()) return super.getContentWriter(request); return new ContentWriter() { @@ -298,8 +297,7 @@ public NamedList processResponse(InputStream b, String encoding) { NamedList nl = new NamedList(); m.forEach( (k, v) -> { - if (v instanceof Map) { - Map map = (Map) v; + if (v instanceof Map map) { if ("response".equals(k)) { v = convertResponse((Map) v); } else { diff --git a/solr/solrj/src/test/org/apache/solr/client/solrj/SolrExampleTests.java b/solr/solrj/src/test/org/apache/solr/client/solrj/SolrExampleTests.java index 2fdadedd953..3e762175b28 100644 --- a/solr/solrj/src/test/org/apache/solr/client/solrj/SolrExampleTests.java +++ b/solr/solrj/src/test/org/apache/solr/client/solrj/SolrExampleTests.java @@ -740,10 +740,8 @@ public void testErrorHandling() throws Exception { ex = expectThrows(SolrException.class, () -> client.add(doc)); assertEquals(400, ex.code()); assertTrue(ex.getMessage().indexOf("contains multiple values for uniqueKey") > 0); - } else if (client instanceof ErrorTrackingConcurrentUpdateSolrClient) { + } else if (client instanceof ErrorTrackingConcurrentUpdateSolrClient concurrentClient) { // XXX concurrentupdatesolrserver reports errors differently - ErrorTrackingConcurrentUpdateSolrClient concurrentClient = - (ErrorTrackingConcurrentUpdateSolrClient) client; concurrentClient.lastError = null; concurrentClient.add(doc); concurrentClient.blockUntilFinished(); @@ -2425,20 +2423,18 @@ public void testUpdateField() throws Exception { if (client instanceof HttpSolrClient) { // XXX concurrent client reports exceptions differently fail("Operation should throw an exception!"); - } else if (client instanceof ErrorTrackingConcurrentUpdateSolrClient) { + } else if (client instanceof ErrorTrackingConcurrentUpdateSolrClient concurrentClient) { client.commit(); // just to be sure the client has sent the doc - ErrorTrackingConcurrentUpdateSolrClient concurrentClient = - (ErrorTrackingConcurrentUpdateSolrClient) client; assertNotNull( "ConcurrentUpdateSolrClient did not report an error", concurrentClient.lastError); assertTrue( "ConcurrentUpdateSolrClient did not report an error", concurrentClient.lastError.getMessage().contains("Conflict")); } else if (client - instanceof SolrExampleStreamingHttp2Test.ErrorTrackingConcurrentUpdateSolrClient) { + instanceof + SolrExampleStreamingHttp2Test.ErrorTrackingConcurrentUpdateSolrClient + concurrentClient) { client.commit(); // just to be sure the client has sent the doc - SolrExampleStreamingHttp2Test.ErrorTrackingConcurrentUpdateSolrClient concurrentClient = - (SolrExampleStreamingHttp2Test.ErrorTrackingConcurrentUpdateSolrClient) client; assertNotNull( "ConcurrentUpdateSolrClient did not report an error", concurrentClient.lastError); assertTrue( diff --git a/solr/solrj/src/test/org/apache/solr/common/util/TestJavaBinCodec.java b/solr/solrj/src/test/org/apache/solr/common/util/TestJavaBinCodec.java index baf36a1cc89..6d02cf82185 100644 --- a/solr/solrj/src/test/org/apache/solr/common/util/TestJavaBinCodec.java +++ b/solr/solrj/src/test/org/apache/solr/common/util/TestJavaBinCodec.java @@ -209,9 +209,7 @@ private void compareObjects(List unmarshalledObj, List matchObj) { assertEquals(unmarshalledObj.size(), matchObj.size()); for (int i = 0; i < unmarshalledObj.size(); i++) { - if (unmarshalledObj.get(i) instanceof byte[] && matchObj.get(i) instanceof byte[]) { - byte[] b1 = (byte[]) unmarshalledObj.get(i); - byte[] b2 = (byte[]) matchObj.get(i); + if (unmarshalledObj.get(i) instanceof byte[] b1 && matchObj.get(i) instanceof byte[] b2) { assertArrayEquals(b1, b2); } else if (unmarshalledObj.get(i) instanceof SolrDocument && matchObj.get(i) instanceof SolrDocument) { diff --git a/solr/test-framework/src/java/org/apache/solr/BaseDistributedSearchTestCase.java b/solr/test-framework/src/java/org/apache/solr/BaseDistributedSearchTestCase.java index f77f9dac942..53848e55776 100644 --- a/solr/test-framework/src/java/org/apache/solr/BaseDistributedSearchTestCase.java +++ b/solr/test-framework/src/java/org/apache/solr/BaseDistributedSearchTestCase.java @@ -938,10 +938,11 @@ public static String compare(Object a, Object b, int flags, Map } if ((flags & FUZZY) != 0) { - if ((a instanceof Double && b instanceof Double)) { - double aaa = (Double) a; - double bbb = (Double) b; - if (aaa == bbb || (((Double) a).isNaN() && ((Double) b).isNaN())) { + + if ((a instanceof Double aa && b instanceof Double bb)) { + double aaa = aa; + double bbb = bb; + if (aaa == bbb || (aa.isNaN() && bb.isNaN())) { return null; } if ((aaa == 0.0) || (bbb == 0.0)) { diff --git a/solr/test-framework/src/java/org/apache/solr/JSONTestUtil.java b/solr/test-framework/src/java/org/apache/solr/JSONTestUtil.java index 029ba3bfbb8..b6b95ef6d7f 100644 --- a/solr/test-framework/src/java/org/apache/solr/JSONTestUtil.java +++ b/solr/test-framework/src/java/org/apache/solr/JSONTestUtil.java @@ -233,8 +233,7 @@ boolean match() { // generic fallback if (!expected.equals(val)) { - if (expected instanceof String) { - String str = (String) expected; + if (expected instanceof String str) { if (str.length() > 6 && str.startsWith("///") && str.endsWith("///")) { return handleSpecialString(str); } diff --git a/solr/test-framework/src/java/org/apache/solr/SolrTestCaseJ4.java b/solr/test-framework/src/java/org/apache/solr/SolrTestCaseJ4.java index 27e9d7a9c33..03388397050 100644 --- a/solr/test-framework/src/java/org/apache/solr/SolrTestCaseJ4.java +++ b/solr/test-framework/src/java/org/apache/solr/SolrTestCaseJ4.java @@ -1765,16 +1765,14 @@ public int hashCode() { @Override public boolean equals(Object o) { - if (!(o instanceof Doc)) return false; - Doc other = (Doc) o; + if (!(o instanceof Doc other)) return false; return this == other || Objects.equals(id, other.id); } @Override @SuppressWarnings({"unchecked"}) public int compareTo(Object o) { - if (!(o instanceof Doc)) return this.getClass().hashCode() - o.getClass().hashCode(); - Doc other = (Doc) o; + if (!(o instanceof Doc other)) return this.getClass().hashCode() - o.getClass().hashCode(); return this.id.compareTo(other.id); } @@ -2350,7 +2348,8 @@ public static String legacyExampleCollection1SolrHome() { public boolean compareSolrDocument(Object expected, Object actual) { - if (!(expected instanceof SolrDocument) || !(actual instanceof SolrDocument)) { + if (!(expected instanceof SolrDocument solrDocument1) + || !(actual instanceof SolrDocument solrDocument2)) { return false; } @@ -2358,9 +2357,6 @@ public boolean compareSolrDocument(Object expected, Object actual) { return true; } - SolrDocument solrDocument1 = (SolrDocument) expected; - SolrDocument solrDocument2 = (SolrDocument) actual; - if (solrDocument1.getFieldNames().size() != solrDocument2.getFieldNames().size()) { return false; } @@ -2401,7 +2397,8 @@ public boolean compareSolrDocument(Object expected, Object actual) { } public boolean compareSolrDocumentList(Object expected, Object actual) { - if (!(expected instanceof SolrDocumentList) || !(actual instanceof SolrDocumentList)) { + if (!(expected instanceof SolrDocumentList list1) + || !(actual instanceof SolrDocumentList list2)) { return false; } @@ -2409,9 +2406,6 @@ public boolean compareSolrDocumentList(Object expected, Object actual) { return true; } - SolrDocumentList list1 = (SolrDocumentList) expected; - SolrDocumentList list2 = (SolrDocumentList) actual; - if (list1.getMaxScore() == null) { if (list2.getMaxScore() != null) { return false; @@ -2435,7 +2429,8 @@ public boolean compareSolrDocumentList(Object expected, Object actual) { public boolean compareSolrInputDocument(Object expected, Object actual) { - if (!(expected instanceof SolrInputDocument) || !(actual instanceof SolrInputDocument)) { + if (!(expected instanceof SolrInputDocument sdoc1) + || !(actual instanceof SolrInputDocument sdoc2)) { return false; } @@ -2443,9 +2438,6 @@ public boolean compareSolrInputDocument(Object expected, Object actual) { return true; } - SolrInputDocument sdoc1 = (SolrInputDocument) expected; - SolrInputDocument sdoc2 = (SolrInputDocument) actual; - if (sdoc1.getFieldNames().size() != sdoc2.getFieldNames().size()) { return false; } @@ -2510,7 +2502,7 @@ public boolean compareSolrInputDocument(Object expected, Object actual) { } public boolean assertSolrInputFieldEquals(Object expected, Object actual) { - if (!(expected instanceof SolrInputField) || !(actual instanceof SolrInputField)) { + if (!(expected instanceof SolrInputField sif1) || !(actual instanceof SolrInputField sif2)) { return false; } @@ -2518,9 +2510,6 @@ public boolean assertSolrInputFieldEquals(Object expected, Object actual) { return true; } - SolrInputField sif1 = (SolrInputField) expected; - SolrInputField sif2 = (SolrInputField) actual; - if (!sif1.getName().equals(sif2.getName())) { return false; } @@ -2944,8 +2933,7 @@ private static SolrDocument toSolrDoc(SolrInputDocument sid) { } private static boolean isChildDoc(Object o) { - if (o instanceof Collection) { - Collection col = (Collection) o; + if (o instanceof Collection col) { if (col.size() == 0) { return false; } diff --git a/solr/test-framework/src/java/org/apache/solr/cloud/AbstractFullDistribZkTestBase.java b/solr/test-framework/src/java/org/apache/solr/cloud/AbstractFullDistribZkTestBase.java index 0a88523f13a..edbf20dc519 100644 --- a/solr/test-framework/src/java/org/apache/solr/cloud/AbstractFullDistribZkTestBase.java +++ b/solr/test-framework/src/java/org/apache/solr/cloud/AbstractFullDistribZkTestBase.java @@ -177,8 +177,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { if (this == obj) return true; - if (!(obj instanceof CloudJettyRunner)) return false; - CloudJettyRunner other = (CloudJettyRunner) obj; + if (!(obj instanceof CloudJettyRunner other)) return false; return Objects.equals(url, other.url); } @@ -215,8 +214,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { if (this == obj) return true; - if (!(obj instanceof CloudSolrServerClient)) return false; - CloudSolrServerClient other = (CloudSolrServerClient) obj; + if (!(obj instanceof CloudSolrServerClient other)) return false; return Objects.equals(solrClient, other.solrClient); } } diff --git a/solr/test-framework/src/java/org/apache/solr/cloud/SolrCloudAuthTestCase.java b/solr/test-framework/src/java/org/apache/solr/cloud/SolrCloudAuthTestCase.java index 1458e7486ab..dab2b845a86 100644 --- a/solr/test-framework/src/java/org/apache/solr/cloud/SolrCloudAuthTestCase.java +++ b/solr/test-framework/src/java/org/apache/solr/cloud/SolrCloudAuthTestCase.java @@ -285,7 +285,7 @@ public static void verifySecurityStatus( verifySecurityStatus(cl, url, objPath, expected, count, makeBasicAuthHeader(user, pwd)); } - @SuppressWarnings({"unchecked"}) + @SuppressWarnings({"unchecked", "rawtypes"}) protected static void verifySecurityStatus( HttpClient cl, String url, String objPath, Object expected, int count, String authHeader) throws IOException, InterruptedException { @@ -297,7 +297,6 @@ protected static void verifySecurityStatus( if (authHeader != null) setAuthorizationHeader(get, authHeader); HttpResponse rsp = cl.execute(get); s = EntityUtils.toString(rsp.getEntity()); - @SuppressWarnings({"rawtypes"}) Map m = null; try { m = (Map) Utils.fromJSONString(s); @@ -306,9 +305,7 @@ protected static void verifySecurityStatus( } Utils.consumeFully(rsp.getEntity()); Object actual = Utils.getObjectByPath(m, true, hierarchy); - if (expected instanceof Predicate) { - @SuppressWarnings({"rawtypes"}) - Predicate predicate = (Predicate) expected; + if (expected instanceof Predicate predicate) { if (predicate.test(actual)) { success = true; break; diff --git a/solr/test-framework/src/java/org/apache/solr/cluster/placement/ClusterAbstractionsForTest.java b/solr/test-framework/src/java/org/apache/solr/cluster/placement/ClusterAbstractionsForTest.java index 43c2d520421..f99490ad75d 100644 --- a/solr/test-framework/src/java/org/apache/solr/cluster/placement/ClusterAbstractionsForTest.java +++ b/solr/test-framework/src/java/org/apache/solr/cluster/placement/ClusterAbstractionsForTest.java @@ -96,8 +96,7 @@ public String toString() { @Override public boolean equals(Object obj) { if (obj == this) return true; - if (!(obj instanceof NodeImpl)) return false; - NodeImpl other = (NodeImpl) obj; + if (!(obj instanceof NodeImpl other)) return false; return Objects.equals(this.nodeName, other.nodeName); } @@ -219,8 +218,7 @@ public ShardState getState() { @Override public boolean equals(Object obj) { if (obj == this) return true; - if (!(obj instanceof ShardImpl)) return false; - ShardImpl other = (ShardImpl) obj; + if (!(obj instanceof ShardImpl other)) return false; return Objects.equals(this.shardName, other.shardName) && Objects.equals(this.collection, other.collection) && Objects.equals(this.shardState, other.shardState) @@ -295,8 +293,7 @@ public Node getNode() { @Override public boolean equals(Object obj) { if (obj == this) return true; - if (!(obj instanceof ReplicaImpl)) return false; - ReplicaImpl other = (ReplicaImpl) obj; + if (!(obj instanceof ReplicaImpl other)) return false; return Objects.equals(this.replicaName, other.replicaName) && Objects.equals(this.coreName, other.coreName) && Objects.equals(this.shard, other.shard) diff --git a/solr/test-framework/src/java/org/apache/solr/core/MockDirectoryFactory.java b/solr/test-framework/src/java/org/apache/solr/core/MockDirectoryFactory.java index 272b93f8e1e..101c465bc4e 100644 --- a/solr/test-framework/src/java/org/apache/solr/core/MockDirectoryFactory.java +++ b/solr/test-framework/src/java/org/apache/solr/core/MockDirectoryFactory.java @@ -54,8 +54,7 @@ protected Directory create(String path, LockFactory lockFactory, DirContext dirC cdir = reduce(cdir); cdir = reduce(cdir); - if (cdir instanceof MockDirectoryWrapper) { - MockDirectoryWrapper mockDirWrapper = (MockDirectoryWrapper) cdir; + if (cdir instanceof MockDirectoryWrapper mockDirWrapper) { // we can't currently do this check because of how // Solr has to reboot a new Directory sometimes when replicating diff --git a/solr/test-framework/src/java/org/apache/solr/util/TestHarness.java b/solr/test-framework/src/java/org/apache/solr/util/TestHarness.java index 7786d1c1d2e..12e8ac4805f 100644 --- a/solr/test-framework/src/java/org/apache/solr/util/TestHarness.java +++ b/solr/test-framework/src/java/org/apache/solr/util/TestHarness.java @@ -355,9 +355,8 @@ public String query(String handler, SolrQueryRequest req) throws Exception { throw rsp.getException(); } QueryResponseWriter responseWriter = core.getQueryResponseWriter(req); - if (responseWriter instanceof BinaryQueryResponseWriter) { + if (responseWriter instanceof BinaryQueryResponseWriter writer) { ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(32000); - BinaryQueryResponseWriter writer = (BinaryQueryResponseWriter) responseWriter; writer.write(byteArrayOutputStream, req, rsp); return new String(byteArrayOutputStream.toByteArray(), StandardCharsets.UTF_8); } else { From 1b966ec054aa5c2f4ef48c869b43fea1ee4f1e4d Mon Sep 17 00:00:00 2001 From: Jason Gerlowski Date: Thu, 21 Nov 2024 11:16:22 -0800 Subject: [PATCH 13/33] SOLR-16825: Migrate v2 API definitions to 'api' module, pt 9 (#2870) SOLR-16825 added a new gradle module, 'api', which holds v2 API definitions as interfaces. This allows us to generate an OAS (and other artifacts) as a part of the solrj build. But these artifacts only cover the v2 APIs present in the 'api' module. This commit moves all remaining v2 API defining annotations to new interfaces in the 'api' module. These APIs are now reflected in our OAS and generated artifacts. --- .../api/endpoint/CollectionBackupApi.java | 58 ++++++ .../api/endpoint/CollectionSnapshotApis.java | 89 ++++++++ .../endpoint/CreateCollectionSnapshotApi.java | 46 ----- .../endpoint/DeleteCollectionSnapshotApi.java | 50 ----- ...kupApi.java => ReplicationBackupApis.java} | 28 +-- .../api/endpoint/ZooKeeperReadApis.java | 69 +++++++ .../DeleteCollectionSnapshotResponse.java | 6 +- .../api/model}/ExperimentalResponse.java | 3 +- .../ListCollectionSnapshotsResponse.java | 31 +++ .../model/ReplicationBackupRequestBody.java | 56 ++++++ .../api/model/ReplicationBackupResponse.java | 35 ++++ .../model/RestoreCollectionRequestBody.java | 40 ++++ .../api/model/ZooKeeperFileResponse.java | 28 +++ .../model/ZooKeeperListChildrenResponse.java | 44 ++++ .../solr/client/api/model/ZooKeeperStat.java | 55 +++++ .../org/apache/solr/core/CoreContainer.java | 4 +- .../handler/admin/CollectionsHandler.java | 22 +- ...okeeperReadAPI.java => ZookeeperRead.java} | 190 +++++------------- .../admin/api/CreateCollectionBackup.java | 4 +- .../admin/api/CreateCollectionSnapshot.java | 5 +- .../admin/api/DeleteCollectionSnapshot.java | 5 +- ...sAPI.java => ListCollectionSnapshots.java} | 40 +--- ...lectionAPI.java => RestoreCollection.java} | 70 ++----- .../handler/admin/api/SnapshotBackupAPI.java | 98 ++------- .../jersey/MediaTypeOverridingFilter.java | 4 +- .../handler/admin/ZookeeperReadAPITest.java | 11 +- .../admin/api/RestoreCollectionAPITest.java | 20 +- .../admin/api/SnapshotBackupAPITest.java | 3 +- 28 files changed, 660 insertions(+), 454 deletions(-) create mode 100644 solr/api/src/java/org/apache/solr/client/api/endpoint/CollectionBackupApi.java create mode 100644 solr/api/src/java/org/apache/solr/client/api/endpoint/CollectionSnapshotApis.java delete mode 100644 solr/api/src/java/org/apache/solr/client/api/endpoint/CreateCollectionSnapshotApi.java delete mode 100644 solr/api/src/java/org/apache/solr/client/api/endpoint/DeleteCollectionSnapshotApi.java rename solr/api/src/java/org/apache/solr/client/api/endpoint/{CreateCollectionBackupApi.java => ReplicationBackupApis.java} (56%) create mode 100644 solr/api/src/java/org/apache/solr/client/api/endpoint/ZooKeeperReadApis.java rename solr/{core/src/java/org/apache/solr/jersey => api/src/java/org/apache/solr/client/api/model}/ExperimentalResponse.java (92%) create mode 100644 solr/api/src/java/org/apache/solr/client/api/model/ListCollectionSnapshotsResponse.java create mode 100644 solr/api/src/java/org/apache/solr/client/api/model/ReplicationBackupRequestBody.java create mode 100644 solr/api/src/java/org/apache/solr/client/api/model/ReplicationBackupResponse.java create mode 100644 solr/api/src/java/org/apache/solr/client/api/model/RestoreCollectionRequestBody.java create mode 100644 solr/api/src/java/org/apache/solr/client/api/model/ZooKeeperFileResponse.java create mode 100644 solr/api/src/java/org/apache/solr/client/api/model/ZooKeeperListChildrenResponse.java create mode 100644 solr/api/src/java/org/apache/solr/client/api/model/ZooKeeperStat.java rename solr/core/src/java/org/apache/solr/handler/admin/{ZookeeperReadAPI.java => ZookeeperRead.java} (51%) rename solr/core/src/java/org/apache/solr/handler/admin/api/{ListCollectionSnapshotsAPI.java => ListCollectionSnapshots.java} (61%) rename solr/core/src/java/org/apache/solr/handler/admin/api/{RestoreCollectionAPI.java => RestoreCollection.java} (76%) diff --git a/solr/api/src/java/org/apache/solr/client/api/endpoint/CollectionBackupApi.java b/solr/api/src/java/org/apache/solr/client/api/endpoint/CollectionBackupApi.java new file mode 100644 index 00000000000..5c6c9d3bbbe --- /dev/null +++ b/solr/api/src/java/org/apache/solr/client/api/endpoint/CollectionBackupApi.java @@ -0,0 +1,58 @@ +/* + * 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.client.api.endpoint; + +import io.swagger.v3.oas.annotations.Operation; +import jakarta.ws.rs.POST; +import jakarta.ws.rs.Path; +import jakarta.ws.rs.PathParam; +import org.apache.solr.client.api.model.CreateCollectionBackupRequestBody; +import org.apache.solr.client.api.model.RestoreCollectionRequestBody; +import org.apache.solr.client.api.model.SolrJerseyResponse; +import org.apache.solr.client.api.model.SubResponseAccumulatingJerseyResponse; + +/** + * V2 API definition for creating a new "backup" of a specified collection + * + *

This API is analogous to the v1 /admin/collections?action=BACKUP command. + */ +public interface CollectionBackupApi { + + @Path("/collections/{collectionName}/backups/{backupName}/versions") + interface Create { + @POST + @Operation( + summary = "Creates a new backup point for a collection", + tags = {"collection-backups"}) + SolrJerseyResponse createCollectionBackup( + @PathParam("collectionName") String collectionName, + @PathParam("backupName") String backupName, + CreateCollectionBackupRequestBody requestBody) + throws Exception; + } + + @Path("/backups/{backupName}/restore") + interface Restore { + @POST + @Operation( + summary = "Restores an existing backup point to a (potentially new) collection.", + tags = {"collection-backups"}) + SubResponseAccumulatingJerseyResponse restoreCollection( + @PathParam("backupName") String backupName, RestoreCollectionRequestBody requestBody) + throws Exception; + } +} diff --git a/solr/api/src/java/org/apache/solr/client/api/endpoint/CollectionSnapshotApis.java b/solr/api/src/java/org/apache/solr/client/api/endpoint/CollectionSnapshotApis.java new file mode 100644 index 00000000000..21c1dc44224 --- /dev/null +++ b/solr/api/src/java/org/apache/solr/client/api/endpoint/CollectionSnapshotApis.java @@ -0,0 +1,89 @@ +/* + * 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.client.api.endpoint; + +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.parameters.RequestBody; +import jakarta.ws.rs.DELETE; +import jakarta.ws.rs.DefaultValue; +import jakarta.ws.rs.GET; +import jakarta.ws.rs.POST; +import jakarta.ws.rs.Path; +import jakarta.ws.rs.PathParam; +import jakarta.ws.rs.QueryParam; +import org.apache.solr.client.api.model.CreateCollectionSnapshotRequestBody; +import org.apache.solr.client.api.model.CreateCollectionSnapshotResponse; +import org.apache.solr.client.api.model.DeleteCollectionSnapshotResponse; +import org.apache.solr.client.api.model.ListCollectionSnapshotsResponse; + +/** V2 API definitions for creating, accessing, and deleting collection-level snapshots. */ +public interface CollectionSnapshotApis { + + @Path("/collections/{collName}/snapshots") + interface Create { + @POST + @Path("/{snapshotName}") + @Operation( + summary = "Creates a new snapshot of the specified collection.", + tags = {"collection-snapshots"}) + CreateCollectionSnapshotResponse createCollectionSnapshot( + @Parameter(description = "The name of the collection.", required = true) + @PathParam("collName") + String collName, + @Parameter(description = "The name of the snapshot to be created.", required = true) + @PathParam("snapshotName") + String snapshotName, + @RequestBody(description = "Contains user provided parameters", required = true) + CreateCollectionSnapshotRequestBody requestBody) + throws Exception; + } + + @Path("/collections/{collName}/snapshots/{snapshotName}") + interface Delete { + @DELETE + @Operation( + summary = "Delete an existing collection-snapshot by name.", + tags = {"collection-snapshots"}) + DeleteCollectionSnapshotResponse deleteCollectionSnapshot( + @Parameter(description = "The name of the collection.", required = true) + @PathParam("collName") + String collName, + @Parameter(description = "The name of the snapshot to be deleted.", required = true) + @PathParam("snapshotName") + String snapshotName, + @Parameter(description = "A flag that treats the collName parameter as a collection alias.") + @DefaultValue("false") + @QueryParam("followAliases") + boolean followAliases, + @QueryParam("async") String asyncId) + throws Exception; + } + + @Path("/collections/{collName}/snapshots") + interface List { + @GET + @Operation( + summary = "List the snapshots available for a specified collection.", + tags = {"collection-snapshots"}) + ListCollectionSnapshotsResponse listSnapshots( + @Parameter(description = "The name of the collection.", required = true) + @PathParam("collName") + String collName) + throws Exception; + } +} diff --git a/solr/api/src/java/org/apache/solr/client/api/endpoint/CreateCollectionSnapshotApi.java b/solr/api/src/java/org/apache/solr/client/api/endpoint/CreateCollectionSnapshotApi.java deleted file mode 100644 index 70240a02e65..00000000000 --- a/solr/api/src/java/org/apache/solr/client/api/endpoint/CreateCollectionSnapshotApi.java +++ /dev/null @@ -1,46 +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.client.api.endpoint; - -import io.swagger.v3.oas.annotations.Operation; -import io.swagger.v3.oas.annotations.Parameter; -import io.swagger.v3.oas.annotations.parameters.RequestBody; -import jakarta.ws.rs.POST; -import jakarta.ws.rs.Path; -import jakarta.ws.rs.PathParam; -import org.apache.solr.client.api.model.CreateCollectionSnapshotRequestBody; -import org.apache.solr.client.api.model.CreateCollectionSnapshotResponse; - -/** V2 API definition for creating a collection-level snapshot. */ -@Path("/collections/{collName}/snapshots") -public interface CreateCollectionSnapshotApi { - @POST - @Path("/{snapshotName}") - @Operation( - summary = "Creates a new snapshot of the specified collection.", - tags = {"collection-snapshots"}) - CreateCollectionSnapshotResponse createCollectionSnapshot( - @Parameter(description = "The name of the collection.", required = true) - @PathParam("collName") - String collName, - @Parameter(description = "The name of the snapshot to be created.", required = true) - @PathParam("snapshotName") - String snapshotName, - @RequestBody(description = "Contains user provided parameters", required = true) - CreateCollectionSnapshotRequestBody requestBody) - throws Exception; -} diff --git a/solr/api/src/java/org/apache/solr/client/api/endpoint/DeleteCollectionSnapshotApi.java b/solr/api/src/java/org/apache/solr/client/api/endpoint/DeleteCollectionSnapshotApi.java deleted file mode 100644 index 8fed7eb4ff9..00000000000 --- a/solr/api/src/java/org/apache/solr/client/api/endpoint/DeleteCollectionSnapshotApi.java +++ /dev/null @@ -1,50 +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.client.api.endpoint; - -import io.swagger.v3.oas.annotations.Operation; -import io.swagger.v3.oas.annotations.Parameter; -import jakarta.ws.rs.DELETE; -import jakarta.ws.rs.DefaultValue; -import jakarta.ws.rs.Path; -import jakarta.ws.rs.PathParam; -import jakarta.ws.rs.QueryParam; -import org.apache.solr.client.api.model.DeleteCollectionSnapshotResponse; - -@Path("/collections/{collName}/snapshots/{snapshotName}") -public interface DeleteCollectionSnapshotApi { - - /** This API is analogous to V1's (POST /solr/admin/collections?action=DELETESNAPSHOT) */ - @DELETE - @Operation( - summary = "Delete an existing collection-snapshot by name.", - tags = {"collection-snapshots"}) - DeleteCollectionSnapshotResponse deleteCollectionSnapshot( - @Parameter(description = "The name of the collection.", required = true) - @PathParam("collName") - String collName, - @Parameter(description = "The name of the snapshot to be deleted.", required = true) - @PathParam("snapshotName") - String snapshotName, - @Parameter(description = "A flag that treats the collName parameter as a collection alias.") - @DefaultValue("false") - @QueryParam("followAliases") - boolean followAliases, - @QueryParam("async") String asyncId) - throws Exception; -} diff --git a/solr/api/src/java/org/apache/solr/client/api/endpoint/CreateCollectionBackupApi.java b/solr/api/src/java/org/apache/solr/client/api/endpoint/ReplicationBackupApis.java similarity index 56% rename from solr/api/src/java/org/apache/solr/client/api/endpoint/CreateCollectionBackupApi.java rename to solr/api/src/java/org/apache/solr/client/api/endpoint/ReplicationBackupApis.java index 3e08bad6d45..ef28f902ecc 100644 --- a/solr/api/src/java/org/apache/solr/client/api/endpoint/CreateCollectionBackupApi.java +++ b/solr/api/src/java/org/apache/solr/client/api/endpoint/ReplicationBackupApis.java @@ -17,27 +17,27 @@ package org.apache.solr.client.api.endpoint; import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.parameters.RequestBody; import jakarta.ws.rs.POST; import jakarta.ws.rs.Path; -import jakarta.ws.rs.PathParam; -import org.apache.solr.client.api.model.CreateCollectionBackupRequestBody; -import org.apache.solr.client.api.model.SolrJerseyResponse; +import org.apache.solr.client.api.model.ReplicationBackupRequestBody; +import org.apache.solr.client.api.model.ReplicationBackupResponse; +import org.apache.solr.client.api.util.CoreApiParameters; /** - * V2 API definition for creating a new "backup" of a specified collection + * V2 endpoint for Backup API used for User-Managed clusters and Single-Node Installation. * - *

This API is analogous to the v1 /admin/collections?action=BACKUP command. + * @see ReplicationApis */ -@Path("/collections/{collectionName}/backups/{backupName}/versions") -public interface CreateCollectionBackupApi { +@Path("/cores/{coreName}/replication") +public interface ReplicationBackupApis { @POST + @CoreApiParameters + @Path("/backups") @Operation( - summary = "Creates a new backup point for a collection", - tags = {"collection-backups"}) - SolrJerseyResponse createCollectionBackup( - @PathParam("collectionName") String collectionName, - @PathParam("backupName") String backupName, - CreateCollectionBackupRequestBody requestBody) - throws Exception; + summary = "Create a backup of a single core using Solr's 'Replication Handler'", + tags = {"replication-backups"}) + ReplicationBackupResponse createBackup( + @RequestBody ReplicationBackupRequestBody backupReplicationPayload); } diff --git a/solr/api/src/java/org/apache/solr/client/api/endpoint/ZooKeeperReadApis.java b/solr/api/src/java/org/apache/solr/client/api/endpoint/ZooKeeperReadApis.java new file mode 100644 index 00000000000..f41e8de3d63 --- /dev/null +++ b/solr/api/src/java/org/apache/solr/client/api/endpoint/ZooKeeperReadApis.java @@ -0,0 +1,69 @@ +/* + * 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.client.api.endpoint; + +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import jakarta.ws.rs.GET; +import jakarta.ws.rs.Path; +import jakarta.ws.rs.PathParam; +import jakarta.ws.rs.Produces; +import jakarta.ws.rs.QueryParam; +import jakarta.ws.rs.core.MediaType; +import org.apache.solr.client.api.model.ZooKeeperFileResponse; +import org.apache.solr.client.api.model.ZooKeeperListChildrenResponse; + +/** V2 API definitions for Solr's ZooKeeper ready-proxy endpoint */ +@Path("/cluster/zookeeper/") +public interface ZooKeeperReadApis { + + @GET + @Path("/data{zkPath:.+}") + @Operation( + summary = "Return the data stored in a specified ZooKeeper node", + tags = {"zookeeper-read"}) + @Produces({"application/vnd.apache.solr.raw", MediaType.APPLICATION_JSON}) + ZooKeeperFileResponse readNode( + @Parameter(description = "The path of the node to read from ZooKeeper") @PathParam("zkPath") + String zkPath); + + // The 'Operation' annotation is omitted intentionally here to ensure this API isn't picked up in + // the OpenAPI spec and consequent code-generation. The server side needs this method to be + // different from 'readNode' above for security reasons (more privileges are needed to access + // security.json), but it's the same logical API expressed by the 'readNode' signature above. + @GET + @Path("/data/security.json") + @Produces({"application/vnd.apache.solr.raw", MediaType.APPLICATION_JSON}) + ZooKeeperFileResponse readSecurityJsonNode(); + + @GET + @Path("/children{zkPath:.*}") + @Produces({"application/json", "application/javabin"}) + @Operation( + summary = "List and stat all children of a specified ZooKeeper node", + tags = {"zookeeper-read"}) + ZooKeeperListChildrenResponse listNodes( + @Parameter(description = "The path of the ZooKeeper node to stat and list children of") + @PathParam("zkPath") + String zkPath, + @Parameter( + description = + "Controls whether stat information for child nodes is included in the response. 'true' by default.") + @QueryParam("children") + Boolean includeChildren) + throws Exception; +} diff --git a/solr/api/src/java/org/apache/solr/client/api/model/DeleteCollectionSnapshotResponse.java b/solr/api/src/java/org/apache/solr/client/api/model/DeleteCollectionSnapshotResponse.java index 569d4fbd096..905b0937f1d 100644 --- a/solr/api/src/java/org/apache/solr/client/api/model/DeleteCollectionSnapshotResponse.java +++ b/solr/api/src/java/org/apache/solr/client/api/model/DeleteCollectionSnapshotResponse.java @@ -21,12 +21,8 @@ import com.fasterxml.jackson.annotation.JsonProperty; import io.swagger.v3.oas.annotations.media.Schema; -import org.apache.solr.client.api.endpoint.DeleteCollectionSnapshotApi; -/** - * The Response for {@link DeleteCollectionSnapshotApi#deleteCollectionSnapshot(String, String, - * boolean, String)} - */ +/** The Response for {@link org.apache.solr.client.api.endpoint.CollectionSnapshotApis.Delete} */ public class DeleteCollectionSnapshotResponse extends AsyncJerseyResponse { @Schema(description = "The name of the collection.") @JsonProperty(COLLECTION) diff --git a/solr/core/src/java/org/apache/solr/jersey/ExperimentalResponse.java b/solr/api/src/java/org/apache/solr/client/api/model/ExperimentalResponse.java similarity index 92% rename from solr/core/src/java/org/apache/solr/jersey/ExperimentalResponse.java rename to solr/api/src/java/org/apache/solr/client/api/model/ExperimentalResponse.java index 7824b7bc314..c460537e3fb 100644 --- a/solr/core/src/java/org/apache/solr/jersey/ExperimentalResponse.java +++ b/solr/api/src/java/org/apache/solr/client/api/model/ExperimentalResponse.java @@ -15,10 +15,9 @@ * limitations under the License. */ -package org.apache.solr.jersey; +package org.apache.solr.client.api.model; import com.fasterxml.jackson.annotation.JsonProperty; -import org.apache.solr.client.api.model.SolrJerseyResponse; /** * {@link SolrJerseyResponse} implementation with a warning field indicating that the format may diff --git a/solr/api/src/java/org/apache/solr/client/api/model/ListCollectionSnapshotsResponse.java b/solr/api/src/java/org/apache/solr/client/api/model/ListCollectionSnapshotsResponse.java new file mode 100644 index 00000000000..962cfda7014 --- /dev/null +++ b/solr/api/src/java/org/apache/solr/client/api/model/ListCollectionSnapshotsResponse.java @@ -0,0 +1,31 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.solr.client.api.model; + +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.media.Schema; +import java.util.Map; + +/** The Response for the v2 "list collection snapshots" API */ +public class ListCollectionSnapshotsResponse extends AsyncJerseyResponse { + + // TODO In practice, map values are of the CollectionSnapshotMetaData type, but that cannot be + // used here until the class is made into more of a POJO and can join the 'api' module here + @Schema(description = "The snapshots for the collection.") + @JsonProperty("snapshots") + public Map snapshots; +} diff --git a/solr/api/src/java/org/apache/solr/client/api/model/ReplicationBackupRequestBody.java b/solr/api/src/java/org/apache/solr/client/api/model/ReplicationBackupRequestBody.java new file mode 100644 index 00000000000..65b93a1d829 --- /dev/null +++ b/solr/api/src/java/org/apache/solr/client/api/model/ReplicationBackupRequestBody.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.client.api.model; + +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.media.Schema; + +public class ReplicationBackupRequestBody { + + public ReplicationBackupRequestBody() {} + + public ReplicationBackupRequestBody( + String location, String name, int numberToKeep, String repository, String commitName) { + this.location = location; + this.name = name; + this.numberToKeep = numberToKeep; + this.repository = repository; + this.commitName = commitName; + } + + @Schema(description = "The path where the backup will be created") + @JsonProperty + public String location; + + @Schema(description = "The backup will be created in a directory called snapshot.") + @JsonProperty + public String name; + + @Schema(description = "The number of backups to keep.") + @JsonProperty + public int numberToKeep; + + @Schema(description = "The name of the repository to be used for e backup.") + @JsonProperty + public String repository; + + @Schema( + description = + "The name of the commit which was used while taking a snapshot using the CREATESNAPSHOT command.") + @JsonProperty + public String commitName; +} diff --git a/solr/api/src/java/org/apache/solr/client/api/model/ReplicationBackupResponse.java b/solr/api/src/java/org/apache/solr/client/api/model/ReplicationBackupResponse.java new file mode 100644 index 00000000000..15581fa734e --- /dev/null +++ b/solr/api/src/java/org/apache/solr/client/api/model/ReplicationBackupResponse.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.client.api.model; + +import com.fasterxml.jackson.annotation.JsonProperty; + +/** Response for the v2 "replication backup" API */ +public class ReplicationBackupResponse extends SolrJerseyResponse { + + @JsonProperty("result") + public Object result; + + @JsonProperty("status") + public String status; + + @JsonProperty("message") + public String message; + + @JsonProperty("exception") + public Exception exception; +} diff --git a/solr/api/src/java/org/apache/solr/client/api/model/RestoreCollectionRequestBody.java b/solr/api/src/java/org/apache/solr/client/api/model/RestoreCollectionRequestBody.java new file mode 100644 index 00000000000..9a592d41e3b --- /dev/null +++ b/solr/api/src/java/org/apache/solr/client/api/model/RestoreCollectionRequestBody.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.client.api.model; + +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.media.Schema; + +/** Request body for the v2 "restore collection" API. */ +public class RestoreCollectionRequestBody { + + @JsonProperty(required = true) + public String collection; + + @JsonProperty public String location; + @JsonProperty public String repository; + @JsonProperty public Integer backupId; + + @Schema( + description = + "Parameters to be used for any collections created by this restore. Only used if the collection specified by the 'collection' property does not exist.", + name = "createCollectionParams") + @JsonProperty("create-collection") + public CreateCollectionRequestBody createCollectionParams; + + @JsonProperty public String async; +} diff --git a/solr/api/src/java/org/apache/solr/client/api/model/ZooKeeperFileResponse.java b/solr/api/src/java/org/apache/solr/client/api/model/ZooKeeperFileResponse.java new file mode 100644 index 00000000000..d09302fa168 --- /dev/null +++ b/solr/api/src/java/org/apache/solr/client/api/model/ZooKeeperFileResponse.java @@ -0,0 +1,28 @@ +/* + * 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.client.api.model; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public class ZooKeeperFileResponse extends SolrJerseyResponse { + // TODO Should be switched over to using StreamingOutput as a part of SOLR-17562 + @JsonProperty("content") // A flag value that RawResponseWriter handles specially + public Object output; + + @JsonProperty("zkData") + public String zkData; +} diff --git a/solr/api/src/java/org/apache/solr/client/api/model/ZooKeeperListChildrenResponse.java b/solr/api/src/java/org/apache/solr/client/api/model/ZooKeeperListChildrenResponse.java new file mode 100644 index 00000000000..be7a69575dc --- /dev/null +++ b/solr/api/src/java/org/apache/solr/client/api/model/ZooKeeperListChildrenResponse.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.client.api.model; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.HashMap; +import java.util.Map; + +public class ZooKeeperListChildrenResponse extends ExperimentalResponse { + @JsonProperty("stat") + public ZooKeeperStat stat; + + // TODO Currently the list response (when child information is fetched) consists primarily of an + // object with only one key - the name of the root node - with separate objects under there for + // each child. The additional nesting under the root node doesn't serve much purpose afaict + // and should be removed. + public Map> unknownFields = new HashMap<>(); + + @JsonAnyGetter + public Map> unknownProperties() { + return unknownFields; + } + + @JsonAnySetter + public void setUnknownProperty(String field, Map value) { + unknownFields.put(field, value); + } +} diff --git a/solr/api/src/java/org/apache/solr/client/api/model/ZooKeeperStat.java b/solr/api/src/java/org/apache/solr/client/api/model/ZooKeeperStat.java new file mode 100644 index 00000000000..302b3885095 --- /dev/null +++ b/solr/api/src/java/org/apache/solr/client/api/model/ZooKeeperStat.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.client.api.model; + +import com.fasterxml.jackson.annotation.JsonProperty; + +/** Represents the data returned by a ZooKeeper 'stat' call */ +public class ZooKeeperStat { + @JsonProperty("version") + public int version; + + @JsonProperty("aversion") + public int aversion; + + @JsonProperty("children") + public int children; + + @JsonProperty("ctime") + public long ctime; + + @JsonProperty("cversion") + public int cversion; + + @JsonProperty("czxid") + public long czxid; + + @JsonProperty("ephemeralOwner") + public long ephemeralOwner; + + @JsonProperty("mtime") + public long mtime; + + @JsonProperty("mzxid") + public long mzxid; + + @JsonProperty("pzxid") + public long pzxid; + + @JsonProperty("dataLength") + public int dataLength; +} diff --git a/solr/core/src/java/org/apache/solr/core/CoreContainer.java b/solr/core/src/java/org/apache/solr/core/CoreContainer.java index 46c584750cb..f30a3787a92 100644 --- a/solr/core/src/java/org/apache/solr/core/CoreContainer.java +++ b/solr/core/src/java/org/apache/solr/core/CoreContainer.java @@ -124,7 +124,7 @@ import org.apache.solr.handler.admin.SecurityConfHandlerLocal; import org.apache.solr.handler.admin.SecurityConfHandlerZk; import org.apache.solr.handler.admin.ZookeeperInfoHandler; -import org.apache.solr.handler.admin.ZookeeperReadAPI; +import org.apache.solr.handler.admin.ZookeeperRead; import org.apache.solr.handler.admin.ZookeeperStatusHandler; import org.apache.solr.handler.api.V2ApiUtils; import org.apache.solr.handler.component.ShardHandlerFactory; @@ -870,7 +870,7 @@ private void loadInternal() { packageLoader = new SolrPackageLoader(this); registerV2ApiIfEnabled(packageLoader.getPackageAPI().editAPI); registerV2ApiIfEnabled(packageLoader.getPackageAPI().readAPI); - registerV2ApiIfEnabled(ZookeeperReadAPI.class); + registerV2ApiIfEnabled(ZookeeperRead.class); } MDCLoggingContext.setNode(this); diff --git a/solr/core/src/java/org/apache/solr/handler/admin/CollectionsHandler.java b/solr/core/src/java/org/apache/solr/handler/admin/CollectionsHandler.java index cec788f2b0b..4e5f24bc985 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/CollectionsHandler.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/CollectionsHandler.java @@ -123,6 +123,7 @@ import org.apache.solr.client.api.model.CreateCollectionSnapshotRequestBody; import org.apache.solr.client.api.model.CreateCollectionSnapshotResponse; import org.apache.solr.client.api.model.InstallShardDataRequestBody; +import org.apache.solr.client.api.model.ListCollectionSnapshotsResponse; import org.apache.solr.client.api.model.ReplaceNodeRequestBody; import org.apache.solr.client.api.model.SolrJerseyResponse; import org.apache.solr.client.api.model.UpdateAliasPropertiesRequestBody; @@ -191,7 +192,7 @@ import org.apache.solr.handler.admin.api.InstallShardData; import org.apache.solr.handler.admin.api.ListAliases; import org.apache.solr.handler.admin.api.ListCollectionBackups; -import org.apache.solr.handler.admin.api.ListCollectionSnapshotsAPI; +import org.apache.solr.handler.admin.api.ListCollectionSnapshots; import org.apache.solr.handler.admin.api.ListCollections; import org.apache.solr.handler.admin.api.MigrateDocsAPI; import org.apache.solr.handler.admin.api.MigrateReplicas; @@ -201,7 +202,7 @@ import org.apache.solr.handler.admin.api.ReloadCollectionAPI; import org.apache.solr.handler.admin.api.RenameCollection; import org.apache.solr.handler.admin.api.ReplaceNode; -import org.apache.solr.handler.admin.api.RestoreCollectionAPI; +import org.apache.solr.handler.admin.api.RestoreCollection; import org.apache.solr.handler.admin.api.SplitShardAPI; import org.apache.solr.handler.admin.api.SyncShard; import org.apache.solr.handler.api.V2ApiUtils; @@ -1063,7 +1064,7 @@ public Map execute( RESTORE_OP( RESTORE, (req, rsp, h) -> { - final var response = RestoreCollectionAPI.invokeFromV1Params(req, rsp, h.coreContainer); + final var response = RestoreCollection.invokeFromV1Params(req, rsp, h.coreContainer); V2ApiUtils.squashIntoSolrResponseWithoutHeader(rsp, response); return null; }), @@ -1148,15 +1149,16 @@ public Map execute( (req, rsp, h) -> { req.getParams().required().check(COLLECTION_PROP); - final ListCollectionSnapshotsAPI listCollectionSnapshotsAPI = - new ListCollectionSnapshotsAPI(h.coreContainer, req, rsp); + final ListCollectionSnapshots listCollectionSnapshotsAPI = + new ListCollectionSnapshots(h.coreContainer, req, rsp); - final ListCollectionSnapshotsAPI.ListSnapshotsResponse response = + final ListCollectionSnapshotsResponse response = listCollectionSnapshotsAPI.listSnapshots(req.getParams().get(COLLECTION_PROP)); NamedList snapshots = new NamedList<>(); - for (CollectionSnapshotMetaData meta : response.snapshots.values()) { - snapshots.add(meta.getName(), meta.toNamedList()); + for (Object meta : response.snapshots.values()) { + final var metaTyped = (CollectionSnapshotMetaData) meta; + snapshots.add(metaTyped.getName(), metaTyped.toNamedList()); } rsp.add(SolrSnapshotManager.SNAPSHOTS_INFO, snapshots); @@ -1375,13 +1377,13 @@ public Collection> getJerseyResources() { ReplaceNode.class, MigrateReplicas.class, BalanceReplicas.class, - RestoreCollectionAPI.class, + RestoreCollection.class, SyncShard.class, CollectionProperty.class, DeleteNode.class, ListAliases.class, AliasProperty.class, - ListCollectionSnapshotsAPI.class, + ListCollectionSnapshots.class, CreateCollectionSnapshot.class, DeleteCollectionSnapshot.class); } diff --git a/solr/core/src/java/org/apache/solr/handler/admin/ZookeeperReadAPI.java b/solr/core/src/java/org/apache/solr/handler/admin/ZookeeperRead.java similarity index 51% rename from solr/core/src/java/org/apache/solr/handler/admin/ZookeeperReadAPI.java rename to solr/core/src/java/org/apache/solr/handler/admin/ZookeeperRead.java index c3e2c4c6a93..8ded06a7a01 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/ZookeeperReadAPI.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/ZookeeperRead.java @@ -17,112 +17,77 @@ package org.apache.solr.handler.admin; -import static org.apache.solr.response.RawResponseWriter.CONTENT; import static org.apache.solr.security.PermissionNameProvider.Name.SECURITY_READ_PERM; import static org.apache.solr.security.PermissionNameProvider.Name.ZK_READ_PERM; -import com.fasterxml.jackson.annotation.JsonAnyGetter; -import com.fasterxml.jackson.annotation.JsonAnySetter; -import com.fasterxml.jackson.annotation.JsonProperty; -import io.swagger.v3.oas.annotations.Parameter; import jakarta.inject.Inject; -import jakarta.ws.rs.GET; -import jakarta.ws.rs.Path; -import jakarta.ws.rs.PathParam; -import jakarta.ws.rs.Produces; -import jakarta.ws.rs.QueryParam; -import jakarta.ws.rs.core.MediaType; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; -import org.apache.solr.client.api.model.SolrJerseyResponse; +import org.apache.solr.client.api.endpoint.ZooKeeperReadApis; +import org.apache.solr.client.api.model.ZooKeeperFileResponse; +import org.apache.solr.client.api.model.ZooKeeperListChildrenResponse; +import org.apache.solr.client.api.model.ZooKeeperStat; import org.apache.solr.client.solrj.impl.BinaryResponseParser; import org.apache.solr.client.solrj.impl.XMLResponseParser; import org.apache.solr.common.SolrException; import org.apache.solr.common.params.CommonParams; -import org.apache.solr.common.util.ContentStream; import org.apache.solr.common.util.ContentStreamBase; import org.apache.solr.core.CoreContainer; import org.apache.solr.handler.admin.api.AdminAPIBase; -import org.apache.solr.jersey.ExperimentalResponse; -import org.apache.solr.jersey.JacksonReflectMapWriter; import org.apache.solr.jersey.PermissionName; import org.apache.solr.request.SolrQueryRequest; -import org.apache.solr.response.RawResponseWriter; import org.apache.solr.response.SolrQueryResponse; import org.apache.zookeeper.KeeperException; import org.apache.zookeeper.data.Stat; /** - * Exposes the content of the Zookeeper This is an expert feature that exposes the data inside the - * back end zookeeper.This API may change or be removed in future versions. This is not a public - * API. The data that is returned is not guaranteed to remain same across releases, as the data - * stored in Zookeeper may change from time to time. + * v2 API definition exposing read-content in Zookeeper. + * + *

This is an expert feature that exposes the data inside the back end zookeeper.This API may + * change or be removed in future versions. This is not a public API. The data that is returned is + * not guaranteed to remain same across releases, as the data stored in Zookeeper may change from + * time to time. * * @lucene.experimental */ -@Path("/cluster/zookeeper/") -public class ZookeeperReadAPI extends AdminAPIBase { +public class ZookeeperRead extends AdminAPIBase implements ZooKeeperReadApis { + + private static final String EMPTY = "empty"; + @Inject - public ZookeeperReadAPI( - CoreContainer coreContainer, SolrQueryRequest req, SolrQueryResponse rsp) { + public ZookeeperRead(CoreContainer coreContainer, SolrQueryRequest req, SolrQueryResponse rsp) { super(coreContainer, req, rsp); } /** Request contents of a znode, except security.json */ - @GET - @Path("/data{zkPath:.+}") - @Produces({RawResponseWriter.CONTENT_TYPE, MediaType.APPLICATION_JSON}) + @Override @PermissionName(ZK_READ_PERM) - public ZooKeeperFileResponse readNode( - @Parameter(description = "The path of the node to read from ZooKeeper") @PathParam("zkPath") - String zkPath) { + public ZooKeeperFileResponse readNode(String zkPath) { zkPath = sanitizeZkPath(zkPath); return readNodeAndAddToResponse(zkPath); } /** Request contents of the security.json node */ - @GET - @Path("/data/security.json") - @Produces({RawResponseWriter.CONTENT_TYPE, MediaType.APPLICATION_JSON}) + @Override @PermissionName(SECURITY_READ_PERM) public ZooKeeperFileResponse readSecurityJsonNode() { return readNodeAndAddToResponse("/security.json"); } - private String sanitizeZkPath(String zkPath) { - if (zkPath == null || zkPath.isEmpty()) { - return "/"; - } else if (zkPath.length() > 1 && zkPath.endsWith("/")) { - return zkPath.substring(0, zkPath.length() - 1); - } - - return zkPath; - } - /** List the children of a certain zookeeper znode */ - @GET - @Path("/children{zkPath:.*}") - @Produces({"application/json", "application/javabin"}) + @Override @PermissionName(ZK_READ_PERM) - public ListZkChildrenResponse listNodes( - @Parameter(description = "The path of the ZooKeeper node to stat and list children of") - @PathParam("zkPath") - String zkPath, - @Parameter( - description = - "Controls whether stat information for child nodes is included in the response. 'true' by default.") - @QueryParam("children") - Boolean includeChildren) + public ZooKeeperListChildrenResponse listNodes(String zkPath, Boolean includeChildren) throws Exception { - final ListZkChildrenResponse listResponse = - instantiateJerseyResponse(ListZkChildrenResponse.class); + final ZooKeeperListChildrenResponse listResponse = + instantiateJerseyResponse(ZooKeeperListChildrenResponse.class); zkPath = sanitizeZkPath(zkPath); try { Stat stat = coreContainer.getZkController().getZkClient().exists(zkPath, null, true); - listResponse.stat = new AnnotatedStat(stat); + listResponse.stat = createAnnotatedStatFrom(stat); if (includeChildren != null && !includeChildren.booleanValue()) { return listResponse; } @@ -140,9 +105,9 @@ public ListZkChildrenResponse listNodes( } } - final Map childStats = new HashMap<>(); + final Map childStats = new HashMap<>(); for (Map.Entry e : stats.entrySet()) { - childStats.put(e.getKey(), new AnnotatedStat(e.getValue())); + childStats.put(e.getKey(), createAnnotatedStatFrom(e.getValue())); } listResponse.unknownFields.put(zkPath, childStats); @@ -152,6 +117,16 @@ public ListZkChildrenResponse listNodes( } } + private String sanitizeZkPath(String zkPath) { + if (zkPath == null || zkPath.isEmpty()) { + return "/"; + } else if (zkPath.length() > 1 && zkPath.endsWith("/")) { + return zkPath.substring(0, zkPath.length() - 1); + } + + return zkPath; + } + /** Simple mime type guessing based on first character of the response */ private String guessMime(byte firstByte) { switch (firstByte) { @@ -193,85 +168,20 @@ private byte[] readPathFromZookeeper(String path) { return d; } - public static class ListZkChildrenResponse extends ExperimentalResponse { - @JsonProperty("stat") - public AnnotatedStat stat; - - // TODO Currently the list response (when child information is fetched) consists primarily of an - // object with only one key - the name of the root node - with separate objects under there for - // each child. The additional nesting under the root node doesn't serve much purpose afaict - // and should be removed. - private Map> unknownFields = new HashMap<>(); - - @JsonAnyGetter - public Map> unknownProperties() { - return unknownFields; - } - - @JsonAnySetter - public void setUnknownProperty(String field, Map value) { - unknownFields.put(field, value); - } - } - - public static class AnnotatedStat implements JacksonReflectMapWriter { - @JsonProperty("version") - public int version; - - @JsonProperty("aversion") - public int aversion; - - @JsonProperty("children") - public int children; - - @JsonProperty("ctime") - public long ctime; - - @JsonProperty("cversion") - public int cversion; - - @JsonProperty("czxid") - public long czxid; - - @JsonProperty("ephemeralOwner") - public long ephemeralOwner; - - @JsonProperty("mtime") - public long mtime; - - @JsonProperty("mzxid") - public long mzxid; - - @JsonProperty("pzxid") - public long pzxid; - - @JsonProperty("dataLength") - public int dataLength; - - public AnnotatedStat(Stat stat) { - this.version = stat.getVersion(); - this.aversion = stat.getAversion(); - this.children = stat.getNumChildren(); - this.ctime = stat.getCtime(); - this.cversion = stat.getCversion(); - this.czxid = stat.getCzxid(); - this.ephemeralOwner = stat.getEphemeralOwner(); - this.mtime = stat.getMtime(); - this.mzxid = stat.getMzxid(); - this.pzxid = stat.getPzxid(); - this.dataLength = stat.getDataLength(); - } - - public AnnotatedStat() {} - } - - private static final String EMPTY = "empty"; - - public static class ZooKeeperFileResponse extends SolrJerseyResponse { - @JsonProperty(CONTENT) // A flag value that RawResponseWriter handles specially - public ContentStream output; - - @JsonProperty("zkData") - public String zkData; + public static ZooKeeperStat createAnnotatedStatFrom(Stat stat) { + final var annotatedStat = new ZooKeeperStat(); + annotatedStat.version = stat.getVersion(); + annotatedStat.aversion = stat.getAversion(); + annotatedStat.children = stat.getNumChildren(); + annotatedStat.ctime = stat.getCtime(); + annotatedStat.cversion = stat.getCversion(); + annotatedStat.czxid = stat.getCzxid(); + annotatedStat.ephemeralOwner = stat.getEphemeralOwner(); + annotatedStat.mtime = stat.getMtime(); + annotatedStat.mzxid = stat.getMzxid(); + annotatedStat.pzxid = stat.getPzxid(); + annotatedStat.dataLength = stat.getDataLength(); + + return annotatedStat; } } diff --git a/solr/core/src/java/org/apache/solr/handler/admin/api/CreateCollectionBackup.java b/solr/core/src/java/org/apache/solr/handler/admin/api/CreateCollectionBackup.java index 09729da6ea2..94c1c7768fa 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/api/CreateCollectionBackup.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/api/CreateCollectionBackup.java @@ -38,7 +38,7 @@ import jakarta.inject.Inject; import java.util.HashMap; import java.util.Map; -import org.apache.solr.client.api.endpoint.CreateCollectionBackupApi; +import org.apache.solr.client.api.endpoint.CollectionBackupApi; import org.apache.solr.client.api.model.CreateCollectionBackupRequestBody; import org.apache.solr.client.api.model.CreateCollectionBackupResponseBody; import org.apache.solr.client.api.model.SolrJerseyResponse; @@ -58,7 +58,7 @@ import org.apache.zookeeper.common.StringUtils; /** V2 API for creating a new "backup" of a specified collection */ -public class CreateCollectionBackup extends BackupAPIBase implements CreateCollectionBackupApi { +public class CreateCollectionBackup extends BackupAPIBase implements CollectionBackupApi.Create { private final ObjectMapper objectMapper; @Inject diff --git a/solr/core/src/java/org/apache/solr/handler/admin/api/CreateCollectionSnapshot.java b/solr/core/src/java/org/apache/solr/handler/admin/api/CreateCollectionSnapshot.java index dd4a7a4033b..9d0a6d295af 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/api/CreateCollectionSnapshot.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/api/CreateCollectionSnapshot.java @@ -26,7 +26,7 @@ import jakarta.inject.Inject; import java.util.HashMap; import java.util.Map; -import org.apache.solr.client.api.endpoint.CreateCollectionSnapshotApi; +import org.apache.solr.client.api.endpoint.CollectionSnapshotApis; import org.apache.solr.client.api.model.CreateCollectionSnapshotRequestBody; import org.apache.solr.client.api.model.CreateCollectionSnapshotResponse; import org.apache.solr.client.solrj.SolrResponse; @@ -43,7 +43,8 @@ import org.apache.solr.response.SolrQueryResponse; /** V2 API implementation for creating a collection-level snapshot. */ -public class CreateCollectionSnapshot extends AdminAPIBase implements CreateCollectionSnapshotApi { +public class CreateCollectionSnapshot extends AdminAPIBase + implements CollectionSnapshotApis.Create { @Inject public CreateCollectionSnapshot( diff --git a/solr/core/src/java/org/apache/solr/handler/admin/api/DeleteCollectionSnapshot.java b/solr/core/src/java/org/apache/solr/handler/admin/api/DeleteCollectionSnapshot.java index 5ead94e0432..abe76571dde 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/api/DeleteCollectionSnapshot.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/api/DeleteCollectionSnapshot.java @@ -26,7 +26,7 @@ import jakarta.inject.Inject; import java.util.HashMap; import java.util.Map; -import org.apache.solr.client.api.endpoint.DeleteCollectionSnapshotApi; +import org.apache.solr.client.api.endpoint.CollectionSnapshotApis; import org.apache.solr.client.api.model.DeleteCollectionSnapshotResponse; import org.apache.solr.client.solrj.SolrResponse; import org.apache.solr.common.cloud.ZkNodeProps; @@ -39,7 +39,8 @@ import org.apache.solr.response.SolrQueryResponse; /** V2 API impl for Deleting Collection Snapshots. */ -public class DeleteCollectionSnapshot extends AdminAPIBase implements DeleteCollectionSnapshotApi { +public class DeleteCollectionSnapshot extends AdminAPIBase + implements CollectionSnapshotApis.Delete { @Inject public DeleteCollectionSnapshot( diff --git a/solr/core/src/java/org/apache/solr/handler/admin/api/ListCollectionSnapshotsAPI.java b/solr/core/src/java/org/apache/solr/handler/admin/api/ListCollectionSnapshots.java similarity index 61% rename from solr/core/src/java/org/apache/solr/handler/admin/api/ListCollectionSnapshotsAPI.java rename to solr/core/src/java/org/apache/solr/handler/admin/api/ListCollectionSnapshots.java index dec0f5998f6..9bbc94f202b 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/api/ListCollectionSnapshotsAPI.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/api/ListCollectionSnapshots.java @@ -16,20 +16,13 @@ */ package org.apache.solr.handler.admin.api; -import static org.apache.solr.client.solrj.impl.BinaryResponseParser.BINARY_CONTENT_TYPE_V2; import static org.apache.solr.security.PermissionNameProvider.Name.COLL_READ_PERM; -import com.fasterxml.jackson.annotation.JsonProperty; -import io.swagger.v3.oas.annotations.Parameter; -import io.swagger.v3.oas.annotations.media.Schema; import jakarta.inject.Inject; -import jakarta.ws.rs.GET; -import jakarta.ws.rs.Path; -import jakarta.ws.rs.PathParam; -import jakarta.ws.rs.Produces; import java.util.Collection; import java.util.Map; -import org.apache.solr.client.api.model.AsyncJerseyResponse; +import org.apache.solr.client.api.endpoint.CollectionSnapshotApis; +import org.apache.solr.client.api.model.ListCollectionSnapshotsResponse; import org.apache.solr.common.cloud.SolrZkClient; import org.apache.solr.common.util.CollectionUtil; import org.apache.solr.core.CoreContainer; @@ -39,12 +32,11 @@ import org.apache.solr.request.SolrQueryRequest; import org.apache.solr.response.SolrQueryResponse; -/** V2 API for Listing Collection Snapshots. */ -@Path("/collections/{collName}/snapshots") -public class ListCollectionSnapshotsAPI extends AdminAPIBase { +/** V2 API implementation for Listing Collection Snapshots. */ +public class ListCollectionSnapshots extends AdminAPIBase implements CollectionSnapshotApis.List { @Inject - public ListCollectionSnapshotsAPI( + public ListCollectionSnapshots( CoreContainer coreContainer, SolrQueryRequest solrQueryRequest, SolrQueryResponse solrQueryResponse) { @@ -52,16 +44,12 @@ public ListCollectionSnapshotsAPI( } /** This API is analogous to V1's (POST /solr/admin/collections?action=LISTSNAPSHOTS) */ - @GET - @Produces({"application/json", "application/xml", BINARY_CONTENT_TYPE_V2}) + @Override @PermissionName(COLL_READ_PERM) - public ListSnapshotsResponse listSnapshots( - @Parameter(description = "The name of the collection.", required = true) - @PathParam("collName") - String collName) - throws Exception { + public ListCollectionSnapshotsResponse listSnapshots(String collName) throws Exception { - final ListSnapshotsResponse response = instantiateJerseyResponse(ListSnapshotsResponse.class); + final ListCollectionSnapshotsResponse response = + instantiateJerseyResponse(ListCollectionSnapshotsResponse.class); final CoreContainer coreContainer = fetchAndValidateZooKeeperAwareCoreContainer(); recordCollectionForLogAndTracing(collName, solrQueryRequest); @@ -71,20 +59,12 @@ public ListSnapshotsResponse listSnapshots( Collection m = SolrSnapshotManager.listSnapshots(client, collectionName); - Map snapshots = CollectionUtil.newHashMap(m.size()); + final Map snapshots = CollectionUtil.newHashMap(m.size()); for (CollectionSnapshotMetaData metaData : m) { snapshots.put(metaData.getName(), metaData); } - response.snapshots = snapshots; return response; } - - /** The Response for {@link ListCollectionSnapshotsAPI}'s {@link #listSnapshots(String)} */ - public static class ListSnapshotsResponse extends AsyncJerseyResponse { - @Schema(description = "The snapshots for the collection.") - @JsonProperty(SolrSnapshotManager.SNAPSHOTS_INFO) - public Map snapshots; - } } diff --git a/solr/core/src/java/org/apache/solr/handler/admin/api/RestoreCollectionAPI.java b/solr/core/src/java/org/apache/solr/handler/admin/api/RestoreCollection.java similarity index 76% rename from solr/core/src/java/org/apache/solr/handler/admin/api/RestoreCollectionAPI.java rename to solr/core/src/java/org/apache/solr/handler/admin/api/RestoreCollection.java index ff8d9ac9690..6d2a9eb25a3 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/api/RestoreCollectionAPI.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/api/RestoreCollection.java @@ -17,8 +17,6 @@ package org.apache.solr.handler.admin.api; -import static org.apache.solr.client.solrj.impl.BinaryResponseParser.BINARY_CONTENT_TYPE_V2; -import static org.apache.solr.client.solrj.request.beans.V2ApiConstants.CREATE_COLLECTION_KEY; import static org.apache.solr.cloud.Overseer.QUEUE_OPERATION; import static org.apache.solr.common.cloud.ZkStateReader.COLLECTION_PROP; import static org.apache.solr.common.params.CollectionAdminParams.COLL_CONF; @@ -35,18 +33,13 @@ import static org.apache.solr.handler.admin.CollectionsHandler.DEFAULT_COLLECTION_OP_TIMEOUT; import static org.apache.solr.security.PermissionNameProvider.Name.COLL_EDIT_PERM; -import com.fasterxml.jackson.annotation.JsonProperty; import jakarta.inject.Inject; -import jakarta.ws.rs.POST; -import jakarta.ws.rs.Path; -import jakarta.ws.rs.PathParam; -import jakarta.ws.rs.Produces; -import java.util.HashMap; import java.util.Map; import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; -import org.apache.solr.client.api.model.CreateCollectionRequestBody; +import org.apache.solr.client.api.endpoint.CollectionBackupApi; +import org.apache.solr.client.api.model.RestoreCollectionRequestBody; import org.apache.solr.client.api.model.SolrJerseyResponse; import org.apache.solr.client.api.model.SubResponseAccumulatingJerseyResponse; import org.apache.solr.client.solrj.SolrResponse; @@ -56,10 +49,10 @@ import org.apache.solr.common.cloud.ZkNodeProps; import org.apache.solr.common.params.CollectionParams; import org.apache.solr.common.params.SolrParams; +import org.apache.solr.common.util.Utils; import org.apache.solr.core.CoreContainer; import org.apache.solr.handler.admin.CollectionsHandler; import org.apache.solr.handler.configsets.ConfigSetAPIBase; -import org.apache.solr.jersey.JacksonReflectMapWriter; import org.apache.solr.jersey.PermissionName; import org.apache.solr.request.SolrQueryRequest; import org.apache.solr.response.SolrQueryResponse; @@ -69,8 +62,7 @@ * *

This API is analogous to the v1 /admin/collections?action=RESTORE command. */ -@Path("/backups/{backupName}/restore") -public class RestoreCollectionAPI extends BackupAPIBase { +public class RestoreCollection extends BackupAPIBase implements CollectionBackupApi.Restore { private static final Set CREATE_PARAM_ALLOWLIST = Stream.concat( @@ -83,19 +75,17 @@ public class RestoreCollectionAPI extends BackupAPIBase { .collect(Collectors.toUnmodifiableSet()); @Inject - public RestoreCollectionAPI( + public RestoreCollection( CoreContainer coreContainer, SolrQueryRequest solrQueryRequest, SolrQueryResponse solrQueryResponse) { super(coreContainer, solrQueryRequest, solrQueryResponse); } - @POST - @Produces({"application/json", "application/xml", BINARY_CONTENT_TYPE_V2}) + @Override @PermissionName(COLL_EDIT_PERM) public SubResponseAccumulatingJerseyResponse restoreCollection( - @PathParam("backupName") String backupName, RestoreCollectionRequestBody requestBody) - throws Exception { + String backupName, RestoreCollectionRequestBody requestBody) throws Exception { final var response = instantiateJerseyResponse(SubResponseAccumulatingJerseyResponse.class); if (requestBody == null) { @@ -159,7 +149,7 @@ public SubResponseAccumulatingJerseyResponse restoreCollection( public ZkNodeProps createRemoteMessage( String backupName, RestoreCollectionRequestBody requestBody) { - final Map remoteMessage = requestBody.toMap(new HashMap<>()); + final Map remoteMessage = Utils.reflectToMap(requestBody); // If the RESTORE is setup to create a new collection, copy those parameters first final var createReqBody = requestBody.createCollectionParams; @@ -177,12 +167,7 @@ public ZkNodeProps createRemoteMessage( // Copy restore-specific parameters remoteMessage.put(QUEUE_OPERATION, CollectionParams.CollectionAction.RESTORE.toLower()); - remoteMessage.put(COLLECTION_PROP, requestBody.collection); remoteMessage.put(NAME, backupName); - remoteMessage.put(BACKUP_LOCATION, requestBody.location); - if (requestBody.backupId != null) remoteMessage.put(BACKUP_ID, requestBody.backupId); - if (requestBody.repository != null) - remoteMessage.put(BACKUP_REPOSITORY, requestBody.repository); remoteMessage.put( TRUSTED, ConfigSetAPIBase.isTrusted( @@ -198,39 +183,24 @@ public static SolrJerseyResponse invokeFromV1Params( final var params = solrQueryRequest.getParams(); params.required().check(NAME, COLLECTION_PROP); final String backupName = params.get(NAME); - final var requestBody = RestoreCollectionRequestBody.fromV1Params(params); + final var requestBody = createRequestBodyFromV1Params(params); final var restoreApi = - new RestoreCollectionAPI(coreContainer, solrQueryRequest, solrQueryResponse); + new RestoreCollection(coreContainer, solrQueryRequest, solrQueryResponse); return restoreApi.restoreCollection(backupName, requestBody); } - /** Request body for the v2 "restore collection" API. */ - public static class RestoreCollectionRequestBody implements JacksonReflectMapWriter { - @JsonProperty(required = true) - public String collection; - - @JsonProperty public String location; - @JsonProperty public String repository; - @JsonProperty public Integer backupId; - - @JsonProperty(CREATE_COLLECTION_KEY) - public CreateCollectionRequestBody createCollectionParams; + public static RestoreCollectionRequestBody createRequestBodyFromV1Params(SolrParams solrParams) { + final var restoreBody = new RestoreCollectionRequestBody(); + restoreBody.collection = solrParams.get(COLLECTION_PROP); + restoreBody.location = solrParams.get(BACKUP_LOCATION); + restoreBody.repository = solrParams.get(BACKUP_REPOSITORY); + restoreBody.backupId = solrParams.getInt(BACKUP_ID); + restoreBody.async = solrParams.get(ASYNC); - @JsonProperty public String async; + restoreBody.createCollectionParams = + CreateCollection.createRequestBodyFromV1Params(solrParams, false); - public static RestoreCollectionRequestBody fromV1Params(SolrParams solrParams) { - final var restoreBody = new RestoreCollectionRequestBody(); - restoreBody.collection = solrParams.get(COLLECTION_PROP); - restoreBody.location = solrParams.get(BACKUP_LOCATION); - restoreBody.repository = solrParams.get(BACKUP_REPOSITORY); - restoreBody.backupId = solrParams.getInt(BACKUP_ID); - restoreBody.async = solrParams.get(ASYNC); - - restoreBody.createCollectionParams = - CreateCollection.createRequestBodyFromV1Params(solrParams, false); - - return restoreBody; - } + return restoreBody; } } diff --git a/solr/core/src/java/org/apache/solr/handler/admin/api/SnapshotBackupAPI.java b/solr/core/src/java/org/apache/solr/handler/admin/api/SnapshotBackupAPI.java index e4024b119c5..d2fbabc04c0 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/api/SnapshotBackupAPI.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/api/SnapshotBackupAPI.java @@ -16,37 +16,33 @@ */ package org.apache.solr.handler.admin.api; -import static org.apache.solr.client.solrj.impl.BinaryResponseParser.BINARY_CONTENT_TYPE_V2; import static org.apache.solr.handler.ReplicationHandler.ERR_STATUS; import static org.apache.solr.security.PermissionNameProvider.Name.CORE_EDIT_PERM; -import io.swagger.v3.oas.annotations.Operation; -import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.parameters.RequestBody; import jakarta.inject.Inject; -import jakarta.ws.rs.POST; -import jakarta.ws.rs.Path; -import jakarta.ws.rs.Produces; -import jakarta.ws.rs.core.MediaType; import java.io.IOException; import java.lang.invoke.MethodHandles; import java.util.function.Consumer; import org.apache.solr.api.JerseyResource; -import org.apache.solr.client.api.model.SolrJerseyResponse; +import org.apache.solr.client.api.endpoint.ReplicationBackupApis; +import org.apache.solr.client.api.model.ReplicationBackupRequestBody; +import org.apache.solr.client.api.model.ReplicationBackupResponse; import org.apache.solr.common.SolrException; -import org.apache.solr.common.annotation.JsonProperty; import org.apache.solr.common.util.NamedList; import org.apache.solr.core.SolrCore; import org.apache.solr.handler.ReplicationHandler; import org.apache.solr.handler.ReplicationHandler.ReplicationHandlerConfig; -import org.apache.solr.jersey.JacksonReflectMapWriter; import org.apache.solr.jersey.PermissionName; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -/** V2 endpoint for Backup API used for User-Managed clusters and Single-Node Installation. */ -@Path("/cores/{coreName}/replication/backups") -public class SnapshotBackupAPI extends JerseyResource { +/** + * v2 API implementation for replication-handler based backup creation. + * + *

This is the main backup functionality available to 'standalone' users. + */ +public class SnapshotBackupAPI extends JerseyResource implements ReplicationBackupApis { private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass()); private final SolrCore solrCore; @@ -62,22 +58,17 @@ public SnapshotBackupAPI(SolrCore solrCore, ReplicationHandlerConfig replication * This API (POST /api/cores/coreName/replication/backups {...}) is analogous to the v1 * /solr/coreName/replication?command=backup */ - @POST - @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML, BINARY_CONTENT_TYPE_V2}) - @Operation(summary = "Backup command using ReplicationHandler") + @Override @PermissionName(CORE_EDIT_PERM) - public BackupReplicationResponse createBackup( - @RequestBody BackupReplicationRequestBody backupReplicationPayload) throws Exception { + public ReplicationBackupResponse createBackup( + @RequestBody ReplicationBackupRequestBody backupReplicationPayload) { ensureRequiredRequestBodyProvided(backupReplicationPayload); - ReplicationHandler replicationHandler = - (ReplicationHandler) solrCore.getRequestHandler(ReplicationHandler.PATH); - return doBackup(replicationHandler, backupReplicationPayload); + return doBackup(backupReplicationPayload); } - private BackupReplicationResponse doBackup( - ReplicationHandler replicationHandler, - BackupReplicationRequestBody backupReplicationPayload) { - BackupReplicationResponse response = instantiateJerseyResponse(BackupReplicationResponse.class); + private ReplicationBackupResponse doBackup( + ReplicationBackupRequestBody backupReplicationPayload) { + ReplicationBackupResponse response = instantiateJerseyResponse(ReplicationBackupResponse.class); int numberToKeep = backupReplicationPayload.numberToKeep; int numberBackupsToKeep = replicationHandlerConfig.getNumberBackupsToKeep(); String location = backupReplicationPayload.location; @@ -128,63 +119,8 @@ protected void doSnapShoot( resultConsumer); } - /* POJO for v2 endpoints request body. */ - public static class BackupReplicationRequestBody implements JacksonReflectMapWriter { - - public BackupReplicationRequestBody() {} - - public BackupReplicationRequestBody( - String location, String name, int numberToKeep, String repository, String commitName) { - this.location = location; - this.name = name; - this.numberToKeep = numberToKeep; - this.repository = repository; - this.commitName = commitName; - } - - @Schema(description = "The path where the backup will be created") - @JsonProperty - public String location; - - @Schema(description = "The backup will be created in a directory called snapshot.") - @JsonProperty - public String name; - - @Schema(description = "The number of backups to keep.") - @JsonProperty - public int numberToKeep; - - @Schema(description = "The name of the repository to be used for e backup.") - @JsonProperty - public String repository; - - @Schema( - description = - "The name of the commit which was used while taking a snapshot using the CREATESNAPSHOT command.") - @JsonProperty - public String commitName; - } - - /** Response for {@link SnapshotBackupAPI#createBackup(BackupReplicationRequestBody)}. */ - public static class BackupReplicationResponse extends SolrJerseyResponse { - - @JsonProperty("result") - public NamedList result; - - @JsonProperty("status") - public String status; - - @JsonProperty("message") - public String message; - - @JsonProperty("exception") - public Exception exception; - - public BackupReplicationResponse() {} - } - private static void reportErrorOnResponse( - BackupReplicationResponse response, String message, Exception e) { + ReplicationBackupResponse response, String message, Exception e) { response.status = ERR_STATUS; response.message = message; if (e != null) { diff --git a/solr/core/src/java/org/apache/solr/jersey/MediaTypeOverridingFilter.java b/solr/core/src/java/org/apache/solr/jersey/MediaTypeOverridingFilter.java index 29695918224..e5a7f7150cc 100644 --- a/solr/core/src/java/org/apache/solr/jersey/MediaTypeOverridingFilter.java +++ b/solr/core/src/java/org/apache/solr/jersey/MediaTypeOverridingFilter.java @@ -29,7 +29,7 @@ import java.io.IOException; import java.util.List; import org.apache.solr.api.JerseyResource; -import org.apache.solr.handler.admin.ZookeeperReadAPI; +import org.apache.solr.handler.admin.ZookeeperRead; import org.apache.solr.handler.api.V2ApiUtils; import org.apache.solr.request.SolrQueryRequest; @@ -39,7 +39,7 @@ public class MediaTypeOverridingFilter implements ContainerResponseFilter { private static final List> EXEMPTED_RESOURCES = - List.of(ZookeeperReadAPI.class); + List.of(ZookeeperRead.class); @Context private ResourceInfo resourceInfo; diff --git a/solr/core/src/test/org/apache/solr/handler/admin/ZookeeperReadAPITest.java b/solr/core/src/test/org/apache/solr/handler/admin/ZookeeperReadAPITest.java index 1a580953c5e..fd87fe340bc 100644 --- a/solr/core/src/test/org/apache/solr/handler/admin/ZookeeperReadAPITest.java +++ b/solr/core/src/test/org/apache/solr/handler/admin/ZookeeperReadAPITest.java @@ -25,6 +25,8 @@ import java.net.URL; import java.util.Map; import java.util.stream.Collectors; +import org.apache.solr.client.api.model.ZooKeeperListChildrenResponse; +import org.apache.solr.client.api.model.ZooKeeperStat; import org.apache.solr.client.solrj.impl.HttpSolrClient; import org.apache.solr.cloud.SolrCloudTestCase; import org.apache.solr.common.SolrException; @@ -35,7 +37,7 @@ import org.junit.BeforeClass; import org.junit.Test; -/** Integration tests for {@link ZookeeperReadAPI} */ +/** Integration tests for {@link ZookeeperRead} */ public class ZookeeperReadAPITest extends SolrCloudTestCase { @BeforeClass public static void setupCluster() throws Exception { @@ -126,13 +128,12 @@ public void testRequestingDataFromNonexistentNodeReturnsAnError() throws Excepti @Test public void testCanListChildNodes() throws Exception { try (HttpSolrClient client = new HttpSolrClient.Builder(baseUrl.toString()).build()) { - final ZookeeperReadAPI.ListZkChildrenResponse response = + final ZooKeeperListChildrenResponse response = Utils.executeGET( client.getHttpClient(), basezkls + "/configs/_default", is -> { - return new ObjectMapper() - .readValue(is, ZookeeperReadAPI.ListZkChildrenResponse.class); + return new ObjectMapper().readValue(is, ZooKeeperListChildrenResponse.class); }); // At the top level, the response contains a key with the value of the specified zkPath @@ -145,7 +146,7 @@ public void testCanListChildNodes() throws Exception { // node. // The actual stat values vary a good bit so aren't very useful to assert on, so let's just // make sure all of the expected child nodes were found. - final Map childStatsByPath = + final Map childStatsByPath = response.unknownProperties().get("/configs/_default"); assertEquals(6, childStatsByPath.size()); assertThat( diff --git a/solr/core/src/test/org/apache/solr/handler/admin/api/RestoreCollectionAPITest.java b/solr/core/src/test/org/apache/solr/handler/admin/api/RestoreCollectionAPITest.java index 922cc989726..e4aab80a2df 100644 --- a/solr/core/src/test/org/apache/solr/handler/admin/api/RestoreCollectionAPITest.java +++ b/solr/core/src/test/org/apache/solr/handler/admin/api/RestoreCollectionAPITest.java @@ -37,6 +37,7 @@ import java.util.Map; import org.apache.solr.SolrTestCaseJ4; import org.apache.solr.client.api.model.CreateCollectionRequestBody; +import org.apache.solr.client.api.model.RestoreCollectionRequestBody; import org.apache.solr.common.SolrException; import org.apache.solr.common.params.ModifiableSolrParams; import org.apache.solr.common.util.NamedList; @@ -46,15 +47,15 @@ import org.junit.BeforeClass; import org.junit.Test; -/** Unit tests for {@link RestoreCollectionAPI} */ +/** Unit tests for {@link RestoreCollection} */ public class RestoreCollectionAPITest extends SolrTestCaseJ4 { - private static RestoreCollectionAPI restoreCollectionAPI; + private static RestoreCollection restoreCollectionAPI; @BeforeClass public static void setUpApi() { restoreCollectionAPI = - new RestoreCollectionAPI( + new RestoreCollection( new CoreContainer( new NodeConfig.NodeConfigBuilder("testnode", createTempDir()).build()), new LocalSolrQueryRequest(null, new NamedList<>()), @@ -63,7 +64,7 @@ public static void setUpApi() { @Test public void testReportsErrorIfBackupNameMissing() { - final var requestBody = new RestoreCollectionAPI.RestoreCollectionRequestBody(); + final var requestBody = new RestoreCollectionRequestBody(); requestBody.collection = "someCollection"; final SolrException thrown = expectThrows( @@ -92,7 +93,7 @@ public void testReportsErrorIfRequestBodyMissing() { @Test public void testReportsErrorIfCollectionNameMissing() { // No 'collection' set on the requestBody - final var requestBody = new RestoreCollectionAPI.RestoreCollectionRequestBody(); + final var requestBody = new RestoreCollectionRequestBody(); final SolrException thrown = expectThrows( SolrException.class, @@ -106,7 +107,7 @@ public void testReportsErrorIfCollectionNameMissing() { @Test public void testReportsErrorIfProvidedCollectionNameIsInvalid() { - final var requestBody = new RestoreCollectionAPI.RestoreCollectionRequestBody(); + final var requestBody = new RestoreCollectionRequestBody(); requestBody.collection = "invalid$collection@name"; final SolrException thrown = expectThrows( @@ -122,7 +123,7 @@ public void testReportsErrorIfProvidedCollectionNameIsInvalid() { @Test public void testCreatesValidRemoteMessageForExistingCollectionRestore() { - final var requestBody = new RestoreCollectionAPI.RestoreCollectionRequestBody(); + final var requestBody = new RestoreCollectionRequestBody(); requestBody.collection = "someCollectionName"; requestBody.location = "/some/location/path"; requestBody.backupId = 123; @@ -145,7 +146,7 @@ public void testCreatesValidRemoteMessageForExistingCollectionRestore() { @Test public void testCreatesValidRemoteMessageForNewCollectionRestore() { - final var requestBody = new RestoreCollectionAPI.RestoreCollectionRequestBody(); + final var requestBody = new RestoreCollectionRequestBody(); requestBody.collection = "someCollectionName"; requestBody.location = "/some/location/path"; requestBody.backupId = 123; @@ -197,8 +198,7 @@ public void testCanConvertV1ParamsIntoV2RequestBody() { v1Params.add("createNodeSet", "node1,node2"); v1Params.add("createNodeSet.shuffle", "false"); - final var requestBody = - RestoreCollectionAPI.RestoreCollectionRequestBody.fromV1Params(v1Params); + final var requestBody = RestoreCollection.createRequestBodyFromV1Params(v1Params); assertEquals("someCollectionName", requestBody.collection); assertEquals("/some/location/str", requestBody.location); diff --git a/solr/core/src/test/org/apache/solr/handler/admin/api/SnapshotBackupAPITest.java b/solr/core/src/test/org/apache/solr/handler/admin/api/SnapshotBackupAPITest.java index dee50c1ebcb..aede987f2b6 100644 --- a/solr/core/src/test/org/apache/solr/handler/admin/api/SnapshotBackupAPITest.java +++ b/solr/core/src/test/org/apache/solr/handler/admin/api/SnapshotBackupAPITest.java @@ -24,6 +24,7 @@ import java.util.concurrent.atomic.AtomicInteger; import java.util.function.Consumer; import org.apache.solr.SolrTestCase; +import org.apache.solr.client.api.model.ReplicationBackupRequestBody; import org.apache.solr.common.SolrException; import org.apache.solr.common.util.NamedList; import org.apache.solr.core.SolrCore; @@ -65,7 +66,7 @@ public void testMissingBody() throws Exception { @Test public void testSuccessfulBackupCommand() throws Exception { when(replicationHandlerConfig.getNumberBackupsToKeep()).thenReturn(11); - final var backupRequestBody = new SnapshotBackupAPI.BackupReplicationRequestBody(); + final var backupRequestBody = new ReplicationBackupRequestBody(); backupRequestBody.name = "test"; backupRequestBody.numberToKeep = 7; From af26a5d0393033fa6bb34bfaaa64279f59aa490f Mon Sep 17 00:00:00 2001 From: cugarte Date: Thu, 21 Nov 2024 16:18:00 -0500 Subject: [PATCH 14/33] SOLR-16390: Tweak v2 clusterprop APIs to be more REST-ful (#2788) This commit changes several v2 "clusterprop" APIs to be more in line with the REST-ful design we're targeting for Solr's v2 APIs. It also adds new v2 clusterprop APIs for listing-all and fetching- single clusterprops. --------- Co-authored-by: Jason Gerlowski --- dev-docs/v2-api-conventions.adoc | 8 + solr/CHANGES.txt | 6 + .../api/endpoint/ClusterPropertyApis.java | 82 ++++++++ .../api/model/ClusterPropertyDetails.java | 31 +++ .../api/model/GetClusterPropertyResponse.java | 27 +++ .../model/ListClusterPropertiesResponse.java | 28 +++ .../model/SetClusterPropertyRequestBody.java | 27 +++ .../org/apache/solr/handler/ClusterAPI.java | 22 --- .../handler/admin/CollectionsHandler.java | 15 +- .../handler/admin/api/ClusterProperty.java | 156 +++++++++++++++ .../solr/cloud/CollectionsAPISolrJTest.java | 30 ++- .../solr/handler/V2ApiIntegrationTest.java | 11 +- .../solr/handler/V2ClusterAPIMappingTest.java | 19 -- .../admin/api/ClusterPropsAPITest.java | 178 ++++++++++++++++++ .../pages/cluster-node-management.adoc | 162 ++++++++++++---- .../src/resources/java-template/api.mustache | 8 +- 16 files changed, 704 insertions(+), 106 deletions(-) create mode 100644 solr/api/src/java/org/apache/solr/client/api/endpoint/ClusterPropertyApis.java create mode 100644 solr/api/src/java/org/apache/solr/client/api/model/ClusterPropertyDetails.java create mode 100644 solr/api/src/java/org/apache/solr/client/api/model/GetClusterPropertyResponse.java create mode 100644 solr/api/src/java/org/apache/solr/client/api/model/ListClusterPropertiesResponse.java create mode 100644 solr/api/src/java/org/apache/solr/client/api/model/SetClusterPropertyRequestBody.java create mode 100644 solr/core/src/java/org/apache/solr/handler/admin/api/ClusterProperty.java create mode 100644 solr/core/src/test/org/apache/solr/handler/admin/api/ClusterPropsAPITest.java diff --git a/dev-docs/v2-api-conventions.adoc b/dev-docs/v2-api-conventions.adoc index d2159239694..74a760c2bfd 100644 --- a/dev-docs/v2-api-conventions.adoc +++ b/dev-docs/v2-api-conventions.adoc @@ -66,6 +66,14 @@ For use within the v2 API, the four "popular" HTTP methods have the following se * `PUT` - used for idempotent resource modifications. * `DELETE` - Used to delete or cleanup resource +== Errors + +v2 APIs should be consistent in how they report errors. Throwing a `SolrException` will convey +1.the error code as the HTTP response status code, as `responseHeader.status` and as `error.code`, and +1.the error message as `error.msg`. + +API calls that reference a specific resource (e.g. `specificCollName`, `specificAliasName`, `specificPropertyName` and others per the above list) that do not exist should return `SolrException.ErrorCode.NOT_FOUND` (HTTP 404). + == Exceptional Cases - "Command" APIs The pairing of semantic HTTP verbs and "resource"-based paths gives Solr an intuitive pattern for representing many operations, but not all. diff --git a/solr/CHANGES.txt b/solr/CHANGES.txt index 03f52515880..ea10c72378b 100644 --- a/solr/CHANGES.txt +++ b/solr/CHANGES.txt @@ -167,6 +167,12 @@ Improvements * SOLR-17390: EmbeddedSolrServer now considers the ResponseParser (David Smiley) +* SOLR-16390: v2 "cluster prop" APIs have been updated to be more REST-ful. Cluster prop creation/update are now available + at `PUT /api/cluster/properties/somePropName`. Deletion is now available at `DELETE /api/cluster/properties/somePropName`. + New APIs for listing-all and fetching-single cluster props are also now available at `GET /api/cluster/properties` and + `GET /api/cluster/properties/somePropName`, respectively. (Carlos Ugarte via Jason Gerlowski) + + Optimizations --------------------- * SOLR-14985: Solrj CloudSolrClient with Solr URLs had serious performance regressions (since the diff --git a/solr/api/src/java/org/apache/solr/client/api/endpoint/ClusterPropertyApis.java b/solr/api/src/java/org/apache/solr/client/api/endpoint/ClusterPropertyApis.java new file mode 100644 index 00000000000..5c75eec0c60 --- /dev/null +++ b/solr/api/src/java/org/apache/solr/client/api/endpoint/ClusterPropertyApis.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.client.api.endpoint; + +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.parameters.RequestBody; +import jakarta.ws.rs.DELETE; +import jakarta.ws.rs.GET; +import jakarta.ws.rs.PUT; +import jakarta.ws.rs.Path; +import jakarta.ws.rs.PathParam; +import java.util.Map; +import org.apache.solr.client.api.model.ListClusterPropertiesResponse; +import org.apache.solr.client.api.model.SetClusterPropertyRequestBody; +import org.apache.solr.client.api.model.SolrJerseyResponse; + +/** Definitions for v2 JAX-RS cluster properties APIs. */ +@Path("/cluster/properties") +public interface ClusterPropertyApis { + @GET + @Operation( + summary = "List all cluster properties in this Solr cluster.", + tags = {"cluster-properties"}) + ListClusterPropertiesResponse listClusterProperties(); + + @GET + @Path("/{propertyName}") + @Operation( + summary = "Get a cluster property in this Solr cluster.", + tags = {"cluster-properties"}) + SolrJerseyResponse getClusterProperty( + @Parameter(description = "The name of the property being retrieved.", required = true) + @PathParam("propertyName") + String propertyName); + + @PUT + @Path("/{propertyName}") + @Operation( + summary = "Set a single new or existing cluster property in this Solr cluster.", + tags = {"cluster-properties"}) + SolrJerseyResponse createOrUpdateClusterProperty( + @Parameter(description = "The name of the property being set.", required = true) + @PathParam("propertyName") + String propertyName, + @RequestBody(description = "Value to set for the property", required = true) + SetClusterPropertyRequestBody requestBody) + throws Exception; + + @PUT + @Operation( + summary = "Set nested cluster properties in this Solr cluster.", + tags = {"cluster-properties"}) + SolrJerseyResponse createOrUpdateNestedClusterProperty( + @RequestBody(description = "Property/ies to be set", required = true) + Map propertyValuesByName) + throws Exception; + + @DELETE + @Path("/{propertyName}") + @Operation( + summary = "Delete a cluster property in this Solr cluster.", + tags = {"cluster-properties"}) + SolrJerseyResponse deleteClusterProperty( + @Parameter(description = "The name of the property being deleted.", required = true) + @PathParam("propertyName") + String propertyName); +} diff --git a/solr/api/src/java/org/apache/solr/client/api/model/ClusterPropertyDetails.java b/solr/api/src/java/org/apache/solr/client/api/model/ClusterPropertyDetails.java new file mode 100644 index 00000000000..9619e96ac1e --- /dev/null +++ b/solr/api/src/java/org/apache/solr/client/api/model/ClusterPropertyDetails.java @@ -0,0 +1,31 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.solr.client.api.model; + +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.media.Schema; + +public class ClusterPropertyDetails { + @JsonProperty("name") + @Schema(description = "The name of the cluster property.") + public String name; + + @JsonProperty("value") + @Schema(description = "The value of the cluster property.") + public Object value; +} diff --git a/solr/api/src/java/org/apache/solr/client/api/model/GetClusterPropertyResponse.java b/solr/api/src/java/org/apache/solr/client/api/model/GetClusterPropertyResponse.java new file mode 100644 index 00000000000..3ebdd74ef60 --- /dev/null +++ b/solr/api/src/java/org/apache/solr/client/api/model/GetClusterPropertyResponse.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.solr.client.api.model; + +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.media.Schema; + +public class GetClusterPropertyResponse extends SolrJerseyResponse { + @JsonProperty("clusterProperty") + @Schema(description = "The requested cluster property.") + public ClusterPropertyDetails clusterProperty; +} diff --git a/solr/api/src/java/org/apache/solr/client/api/model/ListClusterPropertiesResponse.java b/solr/api/src/java/org/apache/solr/client/api/model/ListClusterPropertiesResponse.java new file mode 100644 index 00000000000..46504fb23f1 --- /dev/null +++ b/solr/api/src/java/org/apache/solr/client/api/model/ListClusterPropertiesResponse.java @@ -0,0 +1,28 @@ +/* + * 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.client.api.model; + +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.media.Schema; +import java.util.List; + +public class ListClusterPropertiesResponse extends SolrJerseyResponse { + @JsonProperty("clusterProperties") + @Schema(description = "The list of cluster properties.") + public List clusterProperties; +} diff --git a/solr/api/src/java/org/apache/solr/client/api/model/SetClusterPropertyRequestBody.java b/solr/api/src/java/org/apache/solr/client/api/model/SetClusterPropertyRequestBody.java new file mode 100644 index 00000000000..057f4bcb1d5 --- /dev/null +++ b/solr/api/src/java/org/apache/solr/client/api/model/SetClusterPropertyRequestBody.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.solr.client.api.model; + +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.media.Schema; + +public class SetClusterPropertyRequestBody { + @Schema(description = "The value to assign to the property.") + @JsonProperty("value") + public String value; +} diff --git a/solr/core/src/java/org/apache/solr/handler/ClusterAPI.java b/solr/core/src/java/org/apache/solr/handler/ClusterAPI.java index e161d55e5b3..4807e19aca2 100644 --- a/solr/core/src/java/org/apache/solr/handler/ClusterAPI.java +++ b/solr/core/src/java/org/apache/solr/handler/ClusterAPI.java @@ -23,7 +23,6 @@ import static org.apache.solr.cloud.api.collections.CollectionHandlingUtils.REQUESTID; import static org.apache.solr.common.params.CollectionParams.ACTION; import static org.apache.solr.common.params.CollectionParams.CollectionAction.ADDROLE; -import static org.apache.solr.common.params.CollectionParams.CollectionAction.CLUSTERPROP; import static org.apache.solr.common.params.CollectionParams.CollectionAction.DELETESTATUS; import static org.apache.solr.common.params.CollectionParams.CollectionAction.OVERSEERSTATUS; import static org.apache.solr.common.params.CollectionParams.CollectionAction.REMOVEROLE; @@ -43,7 +42,6 @@ import org.apache.solr.api.EndPoint; import org.apache.solr.api.PayloadObj; import org.apache.solr.client.solrj.cloud.DistribStateManager; -import org.apache.solr.client.solrj.request.beans.ClusterPropPayload; import org.apache.solr.client.solrj.request.beans.RateLimiterPayload; import org.apache.solr.common.SolrException; import org.apache.solr.common.annotation.JsonProperty; @@ -275,26 +273,6 @@ public void removeRole(PayloadObj obj) throws Exception { collectionsHandler.handleRequestBody(wrapParams(obj.getRequest(), m), obj.getResponse()); } - @Command(name = "set-obj-property") - public void setObjProperty(PayloadObj obj) { - // Not using the object directly here because the API differentiate between {name:null} and {} - Map m = obj.getDataMap(); - ClusterProperties clusterProperties = - new ClusterProperties(getCoreContainer().getZkController().getZkClient()); - try { - clusterProperties.setClusterProperties(m); - } catch (Exception e) { - throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Error in API", e); - } - } - - @Command(name = "set-property") - public void setProperty(PayloadObj> obj) throws Exception { - Map m = obj.getDataMap(); - m.put("action", CLUSTERPROP.toString()); - collectionsHandler.handleRequestBody(wrapParams(obj.getRequest(), m), obj.getResponse()); - } - @Command(name = "set-ratelimiter") public void setRateLimiters(PayloadObj payLoad) { RateLimiterPayload rateLimiterConfig = payLoad.get(); diff --git a/solr/core/src/java/org/apache/solr/handler/admin/CollectionsHandler.java b/solr/core/src/java/org/apache/solr/handler/admin/CollectionsHandler.java index 4e5f24bc985..df6ba086d06 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/CollectionsHandler.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/CollectionsHandler.java @@ -125,6 +125,7 @@ import org.apache.solr.client.api.model.InstallShardDataRequestBody; import org.apache.solr.client.api.model.ListCollectionSnapshotsResponse; import org.apache.solr.client.api.model.ReplaceNodeRequestBody; +import org.apache.solr.client.api.model.SetClusterPropertyRequestBody; import org.apache.solr.client.api.model.SolrJerseyResponse; import org.apache.solr.client.api.model.UpdateAliasPropertiesRequestBody; import org.apache.solr.client.api.model.UpdateCollectionPropertyRequestBody; @@ -142,7 +143,6 @@ import org.apache.solr.cloud.api.collections.ReindexCollectionCmd; import org.apache.solr.common.SolrException; import org.apache.solr.common.SolrException.ErrorCode; -import org.apache.solr.common.cloud.ClusterProperties; import org.apache.solr.common.cloud.DocCollection; import org.apache.solr.common.cloud.Replica; import org.apache.solr.common.cloud.Replica.State; @@ -172,6 +172,7 @@ import org.apache.solr.handler.admin.api.AliasProperty; import org.apache.solr.handler.admin.api.BalanceReplicas; import org.apache.solr.handler.admin.api.BalanceShardUnique; +import org.apache.solr.handler.admin.api.ClusterProperty; import org.apache.solr.handler.admin.api.CollectionProperty; import org.apache.solr.handler.admin.api.CollectionStatusAPI; import org.apache.solr.handler.admin.api.CreateAlias; @@ -771,11 +772,12 @@ public enum CollectionOperation implements CollectionOp { CLUSTERPROP_OP( CLUSTERPROP, (req, rsp, h) -> { + ClusterProperty clusterProperty = new ClusterProperty(req.getCoreContainer(), req, rsp); + SetClusterPropertyRequestBody setClusterPropertyRequestBody = + new SetClusterPropertyRequestBody(); String name = req.getParams().required().get(NAME); - String val = req.getParams().get(VALUE_LONG); - ClusterProperties cp = - new ClusterProperties(h.coreContainer.getZkController().getZkClient()); - cp.setClusterProperty(name, val); + setClusterPropertyRequestBody.value = req.getParams().get(VALUE_LONG); + clusterProperty.createOrUpdateClusterProperty(name, setClusterPropertyRequestBody); return null; }), COLLECTIONPROP_OP( @@ -1385,7 +1387,8 @@ public Collection> getJerseyResources() { AliasProperty.class, ListCollectionSnapshots.class, CreateCollectionSnapshot.class, - DeleteCollectionSnapshot.class); + DeleteCollectionSnapshot.class, + ClusterProperty.class); } @Override diff --git a/solr/core/src/java/org/apache/solr/handler/admin/api/ClusterProperty.java b/solr/core/src/java/org/apache/solr/handler/admin/api/ClusterProperty.java new file mode 100644 index 00000000000..efce79f7e84 --- /dev/null +++ b/solr/core/src/java/org/apache/solr/handler/admin/api/ClusterProperty.java @@ -0,0 +1,156 @@ +/* + * 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.handler.admin.api; + +import static org.apache.solr.security.PermissionNameProvider.Name.COLL_EDIT_PERM; +import static org.apache.solr.security.PermissionNameProvider.Name.COLL_READ_PERM; + +import jakarta.inject.Inject; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Map; +import org.apache.solr.client.api.endpoint.ClusterPropertyApis; +import org.apache.solr.client.api.model.ClusterPropertyDetails; +import org.apache.solr.client.api.model.GetClusterPropertyResponse; +import org.apache.solr.client.api.model.ListClusterPropertiesResponse; +import org.apache.solr.client.api.model.SetClusterPropertyRequestBody; +import org.apache.solr.client.api.model.SolrJerseyResponse; +import org.apache.solr.common.SolrException; +import org.apache.solr.common.cloud.ClusterProperties; +import org.apache.solr.core.CoreContainer; +import org.apache.solr.jersey.PermissionName; +import org.apache.solr.request.SolrQueryRequest; +import org.apache.solr.response.SolrQueryResponse; + +public class ClusterProperty extends AdminAPIBase implements ClusterPropertyApis { + protected final ClusterProperties clusterProperties; + + @Inject + public ClusterProperty( + CoreContainer coreContainer, + SolrQueryRequest solrQueryRequest, + SolrQueryResponse solrQueryResponse) { + super(coreContainer, solrQueryRequest, solrQueryResponse); + this.clusterProperties = + new ClusterProperties( + fetchAndValidateZooKeeperAwareCoreContainer().getZkController().getZkClient()); + } + + /** + * V2 API for listing cluster properties. + * + *

This API (GET /api/cluster/properties) has no v1 equivalent. + */ + @Override + @PermissionName(COLL_READ_PERM) + public ListClusterPropertiesResponse listClusterProperties() { + ListClusterPropertiesResponse response = + instantiateJerseyResponse(ListClusterPropertiesResponse.class); + + try { + response.clusterProperties = + new ArrayList<>(clusterProperties.getClusterProperties().keySet()); + } catch (IOException e) { + throw new RuntimeException(e); + } + + return response; + } + + /** + * V2 API for returning the value of a cluster property. + * + *

This API (GET /api/cluster/properties/{propertyName}) has no v1 equivalent. + */ + @Override + @PermissionName(COLL_READ_PERM) + public SolrJerseyResponse getClusterProperty(String propertyName) { + GetClusterPropertyResponse response = + instantiateJerseyResponse(GetClusterPropertyResponse.class); + + try { + Object value = clusterProperties.getClusterProperties().get(propertyName); + if (value != null) { + response.clusterProperty = new ClusterPropertyDetails(); + response.clusterProperty.name = propertyName; + response.clusterProperty.value = value; + } else { + throw new SolrException( + SolrException.ErrorCode.NOT_FOUND, "No such cluster property [" + propertyName + "]"); + } + } catch (IOException e) { + throw new RuntimeException(e); + } + + return response; + } + + /** + * V2 API for setting the value of a single new or existing cluster property. + * + *

This API (PUT /api/cluster/properties/{propertyName} with an object listing the value) is + * equivalent to the v1 GET + * /solr/admin/collections?action=CLUSTERPROP&name={propertyName}&val={propertyValue} API. + */ + @Override + @PermissionName(COLL_EDIT_PERM) + public SolrJerseyResponse createOrUpdateClusterProperty( + String propertyName, SetClusterPropertyRequestBody requestBody) throws IOException { + SolrJerseyResponse response = instantiateJerseyResponse(SolrJerseyResponse.class); + clusterProperties.setClusterProperty(propertyName, requestBody.value); + return response; + } + + /** + * V2 API for setting the value of nested cluster properties. + * + *

This API (PUT /api/cluster/properties with an object listing those properties) has no v1 + * equivalent. + */ + @Override + @PermissionName(COLL_EDIT_PERM) + public SolrJerseyResponse createOrUpdateNestedClusterProperty( + Map propertyValuesByName) { + SolrJerseyResponse response = instantiateJerseyResponse(SolrJerseyResponse.class); + try { + clusterProperties.setClusterProperties(propertyValuesByName); + } catch (Exception e) { + throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Error in API", e); + } + return response; + } + + /** + * V2 API for deleting a cluster property. + * + *

This API (DELETE /api/cluster/properties/{propertyName}) is equivalent to the v1 GET + * /solr/admin/collections?action=CLUSTERPROP&name={propertyName} API. + */ + @PermissionName(COLL_EDIT_PERM) + @Override + public SolrJerseyResponse deleteClusterProperty(String propertyName) { + final var response = instantiateJerseyResponse(SolrJerseyResponse.class); + + try { + clusterProperties.setClusterProperty(propertyName, null); + } catch (IOException e) { + throw new RuntimeException(e); + } + + return response; + } +} diff --git a/solr/core/src/test/org/apache/solr/cloud/CollectionsAPISolrJTest.java b/solr/core/src/test/org/apache/solr/cloud/CollectionsAPISolrJTest.java index cf338640579..0fe1b755d62 100644 --- a/solr/core/src/test/org/apache/solr/cloud/CollectionsAPISolrJTest.java +++ b/solr/core/src/test/org/apache/solr/cloud/CollectionsAPISolrJTest.java @@ -133,10 +133,10 @@ public void testCreateCollWithDefaultClusterPropertiesNewFormat() throws Excepti String COLL_NAME = "CollWithDefaultClusterProperties"; try { V2Response rsp = - new V2Request.Builder("/cluster") - .withMethod(SolrRequest.METHOD.POST) + new V2Request.Builder("/cluster/properties") + .withMethod(SolrRequest.METHOD.PUT) .withPayload( - "{set-obj-property:{defaults : {collection:{numShards : 2 , nrtReplicas : 2}}}}") + "{\"defaults\": {\"collection\": {\"numShards\": 2, \"nrtReplicas\": 2}}}") .build() .process(cluster.getSolrClient()); @@ -172,15 +172,13 @@ public void testCreateCollWithDefaultClusterPropertiesNewFormat() throws Excepti // unset only a single value rsp = - new V2Request.Builder("/cluster") - .withMethod(SolrRequest.METHOD.POST) + new V2Request.Builder("/cluster/properties") + .withMethod(SolrRequest.METHOD.PUT) .withPayload( "{\n" - + " \"set-obj-property\": {\n" - + " \"defaults\" : {\n" - + " \"collection\": {\n" - + " \"nrtReplicas\": null\n" - + " }\n" + + " \"defaults\" : {\n" + + " \"collection\": {\n" + + " \"nrtReplicas\": null\n" + " }\n" + " }\n" + "}") @@ -199,9 +197,9 @@ public void testCreateCollWithDefaultClusterPropertiesNewFormat() throws Excepti assertNull(clusterProperty); rsp = - new V2Request.Builder("/cluster") - .withMethod(SolrRequest.METHOD.POST) - .withPayload("{set-obj-property:{defaults: {collection:null}}}") + new V2Request.Builder("/cluster/properties") + .withMethod(SolrRequest.METHOD.PUT) + .withPayload("{\"defaults\": {\"collection\": null}}") .build() .process(cluster.getSolrClient()); // assert that it is really gone in both old and new paths @@ -216,9 +214,9 @@ public void testCreateCollWithDefaultClusterPropertiesNewFormat() throws Excepti assertNull(clusterProperty); } finally { V2Response rsp = - new V2Request.Builder("/cluster") - .withMethod(SolrRequest.METHOD.POST) - .withPayload("{set-obj-property:{defaults: null}}") + new V2Request.Builder("/cluster/properties") + .withMethod(SolrRequest.METHOD.PUT) + .withPayload("{\"defaults\": null}") .build() .process(cluster.getSolrClient()); } diff --git a/solr/core/src/test/org/apache/solr/handler/V2ApiIntegrationTest.java b/solr/core/src/test/org/apache/solr/handler/V2ApiIntegrationTest.java index 651d4a8ed93..a7f4606e160 100644 --- a/solr/core/src/test/org/apache/solr/handler/V2ApiIntegrationTest.java +++ b/solr/core/src/test/org/apache/solr/handler/V2ApiIntegrationTest.java @@ -155,18 +155,17 @@ public void testSetPropertyValidationOfCluster() throws IOException, SolrServerE cluster .getSolrClient() .request( - new V2Request.Builder("/cluster") - .withMethod(SolrRequest.METHOD.POST) - .withPayload("{set-property: {name: maxCoresPerNode, val:42}}") + new V2Request.Builder("/cluster/properties/maxCoresPerNode") + .withMethod(SolrRequest.METHOD.PUT) + .withPayload("{\"value\": \"42\"}") .build()); assertTrue(resp.toString().contains("status=0")); resp = cluster .getSolrClient() .request( - new V2Request.Builder("/cluster") - .withMethod(SolrRequest.METHOD.POST) - .withPayload("{set-property: {name: maxCoresPerNode, val:null}}") + new V2Request.Builder("/cluster/properties/maxCoresPerNode") + .withMethod(SolrRequest.METHOD.DELETE) .build()); assertTrue(resp.toString().contains("status=0")); } diff --git a/solr/core/src/test/org/apache/solr/handler/V2ClusterAPIMappingTest.java b/solr/core/src/test/org/apache/solr/handler/V2ClusterAPIMappingTest.java index 94f091fba2a..6410dc60a47 100644 --- a/solr/core/src/test/org/apache/solr/handler/V2ClusterAPIMappingTest.java +++ b/solr/core/src/test/org/apache/solr/handler/V2ClusterAPIMappingTest.java @@ -19,7 +19,6 @@ import static org.apache.solr.cloud.api.collections.CollectionHandlingUtils.REQUESTID; import static org.apache.solr.common.params.CommonParams.ACTION; -import static org.apache.solr.common.params.CommonParams.NAME; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -128,29 +127,11 @@ public void testRemoveRoleAllParams() throws Exception { assertEquals("some_role", v1Params.get("role")); } - @Test - public void testSetPropertyAllParams() throws Exception { - final SolrParams v1Params = - captureConvertedV1Params( - "/cluster", - "POST", - "{'set-property': {" + "'name': 'some_prop_name', " + "'val':'some_value'}}"); - - assertEquals(CollectionParams.CollectionAction.CLUSTERPROP.toString(), v1Params.get(ACTION)); - assertEquals("some_prop_name", v1Params.get(NAME)); - assertEquals("some_value", v1Params.get("val")); - } - private SolrParams captureConvertedV1Params(String path, String method, String v2RequestBody) throws Exception { return doCaptureParams(path, method, v2RequestBody, mockCollectionsHandler); } - private SolrParams captureConvertedConfigsetV1Params( - String path, String method, String v2RequestBody) throws Exception { - return doCaptureParams(path, method, v2RequestBody, mockConfigSetHandler); - } - private SolrParams doCaptureParams( String path, String method, String v2RequestBody, RequestHandlerBase mockHandler) throws Exception { diff --git a/solr/core/src/test/org/apache/solr/handler/admin/api/ClusterPropsAPITest.java b/solr/core/src/test/org/apache/solr/handler/admin/api/ClusterPropsAPITest.java new file mode 100644 index 00000000000..9ae628e71eb --- /dev/null +++ b/solr/core/src/test/org/apache/solr/handler/admin/api/ClusterPropsAPITest.java @@ -0,0 +1,178 @@ +/* + * 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.handler.admin.api; + +import static org.apache.solr.common.util.Utils.getObjectByPath; + +import java.net.URL; +import java.util.List; +import org.apache.http.HttpResponse; +import org.apache.http.client.methods.HttpDelete; +import org.apache.http.client.methods.HttpGet; +import org.apache.http.client.methods.HttpPut; +import org.apache.http.entity.StringEntity; +import org.apache.solr.client.solrj.impl.HttpSolrClient; +import org.apache.solr.cloud.SolrCloudTestCase; +import org.apache.solr.common.util.Utils; +import org.junit.After; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; + +public class ClusterPropsAPITest extends SolrCloudTestCase { + + private URL baseUrl; + private String baseUrlV2ClusterProps; + + private static final String testClusterProperty = "ext.test"; + private static final String testClusterPropertyValue = "test value"; + private static final String testClusterPropertyNestedKeyAndValue = + " \"defaults\": {" + + " \"collection\": {" + + " \"numShards\": 4," + + " \"nrtReplicas\": 2," + + " \"tlogReplicas\": 2," + + " \"pullReplicas\": 2" + + " }" + + " }"; + private static final String testClusterPropertyBulkAndNestedValues = + "{" + + testClusterPropertyNestedKeyAndValue + + "," + + " \"" + + testClusterProperty + + "\": " + + "\"" + + testClusterPropertyValue + + "\"" + + " }"; + + @BeforeClass + public static void setupCluster() throws Exception { + configureCluster(1).addConfig("conf", configset("cloud-minimal")).configure(); + } + + @Before + @Override + public void setUp() throws Exception { + super.setUp(); + + baseUrl = cluster.getJettySolrRunner(0).getBaseUrl(); + baseUrlV2ClusterProps = + cluster.getJettySolrRunner(0).getBaseURLV2().toString() + "/cluster/properties"; + } + + @After + @Override + public void tearDown() throws Exception { + super.tearDown(); + } + + @Test + public void testClusterPropertyOpsAllGood() throws Exception { + try (HttpSolrClient client = new HttpSolrClient.Builder(baseUrl.toString()).build()) { + // List Properties, confirm there aren't any + Object o = + Utils.executeGET(client.getHttpClient(), baseUrlV2ClusterProps, Utils.JSONCONSUMER); + assertNotNull(o); + assertEquals(0, ((List) getObjectByPath(o, true, "clusterProperties")).size()); + + // Create a single cluster property + String path = baseUrlV2ClusterProps + "/" + testClusterProperty; + HttpPut httpPut = new HttpPut(path); + httpPut.setHeader("Content-Type", "application/json"); + httpPut.setEntity(new StringEntity("{\"value\":\"" + testClusterPropertyValue + "\"}")); + o = Utils.executeHttpMethod(client.getHttpClient(), path, Utils.JSONCONSUMER, httpPut); + assertNotNull(o); + + // List Properties, this time there should be 1 + o = Utils.executeGET(client.getHttpClient(), baseUrlV2ClusterProps, Utils.JSONCONSUMER); + assertNotNull(o); + assertEquals(1, ((List) getObjectByPath(o, true, "clusterProperties")).size()); + assertEquals( + testClusterProperty, + (String) ((List) getObjectByPath(o, true, "clusterProperties")).get(0)); + + // Fetch Cluster Property + // Same path as used in the Create step above + o = Utils.executeGET(client.getHttpClient(), path, Utils.JSONCONSUMER); + assertNotNull(o); + assertEquals(testClusterProperty, (String) getObjectByPath(o, true, "clusterProperty/name")); + assertEquals( + testClusterPropertyValue, (String) getObjectByPath(o, true, "clusterProperty/value")); + + // Delete Cluster Property + // Same path as used in the Create step above + HttpDelete httpDelete = new HttpDelete(path); + o = Utils.executeHttpMethod(client.getHttpClient(), path, Utils.JSONCONSUMER, httpDelete); + assertNotNull(o); + + // List Properties, should be back to 0 + o = Utils.executeGET(client.getHttpClient(), baseUrlV2ClusterProps, Utils.JSONCONSUMER); + assertNotNull(o); + assertEquals(0, ((List) getObjectByPath(o, true, "clusterProperties")).size()); + } + } + + @Test + public void testClusterPropertyNestedBulkSet() throws Exception { + try (HttpSolrClient client = new HttpSolrClient.Builder(baseUrl.toString()).build()) { + // Create a single cluster property using the Bulk/Nested set ClusterProp API + HttpPut httpPut = new HttpPut(baseUrlV2ClusterProps); + httpPut.setHeader("Content-Type", "application/json"); + httpPut.setEntity(new StringEntity(testClusterPropertyBulkAndNestedValues)); + Object o = + Utils.executeHttpMethod( + client.getHttpClient(), baseUrlV2ClusterProps, Utils.JSONCONSUMER, httpPut); + assertNotNull(o); + + // Fetch Cluster Property checking the not-nested property set above + String path = baseUrlV2ClusterProps + "/" + testClusterProperty; + o = Utils.executeGET(client.getHttpClient(), path, Utils.JSONCONSUMER); + assertNotNull(o); + assertEquals(testClusterProperty, (String) getObjectByPath(o, true, "clusterProperty/name")); + assertEquals( + testClusterPropertyValue, (String) getObjectByPath(o, true, "clusterProperty/value")); + + // Fetch Cluster Property checking the nested property set above + path = baseUrlV2ClusterProps + "/" + "defaults"; + o = Utils.executeGET(client.getHttpClient(), path, Utils.JSONCONSUMER); + assertNotNull(o); + assertEquals("defaults", (String) getObjectByPath(o, true, "clusterProperty/name")); + assertEquals(4L, getObjectByPath(o, true, "clusterProperty/value/collection/numShards")); + + // Clean up to leave the state unchanged + HttpDelete httpDelete = new HttpDelete(path); + Utils.executeHttpMethod(client.getHttpClient(), path, Utils.JSONCONSUMER, httpDelete); + path = baseUrlV2ClusterProps + "/" + testClusterProperty; + httpDelete = new HttpDelete(path); + Utils.executeHttpMethod(client.getHttpClient(), path, Utils.JSONCONSUMER, httpDelete); + } + } + + @Test + public void testClusterPropertyFetchNonExistentProperty() throws Exception { + try (HttpSolrClient client = new HttpSolrClient.Builder(baseUrl.toString()).build()) { + // Fetch Cluster Property that doesn't exist + String path = baseUrlV2ClusterProps + "/ext.clusterPropThatDoesNotExist"; + HttpGet fetchClusterPropertyGet = new HttpGet(path); + HttpResponse httpResponse = client.getHttpClient().execute(fetchClusterPropertyGet); + assertEquals(404, httpResponse.getStatusLine().getStatusCode()); + } + } +} diff --git a/solr/solr-ref-guide/modules/deployment-guide/pages/cluster-node-management.adoc b/solr/solr-ref-guide/modules/deployment-guide/pages/cluster-node-management.adoc index 6765c1ca93b..1f3fdf0b1bb 100644 --- a/solr/solr-ref-guide/modules/deployment-guide/pages/cluster-node-management.adoc +++ b/solr/solr-ref-guide/modules/deployment-guide/pages/cluster-node-management.adoc @@ -246,36 +246,40 @@ http://localhost:8983/solr/admin/collections?action=CLUSTERPROP&name=urlScheme&v V2 API:: + ==== +To create or update a cluster property: [source,bash] ---- -curl -X POST http://localhost:8983/api/cluster -H 'Content-Type: application/json' -d ' +curl -X PUT http://localhost:8983/api/cluster/properties/urlScheme -H 'Content-Type: application/json' -d ' { - "set-property": { - "name": "urlScheme", - "val": "https" - } + "value": "https" } ' ---- + +To delete an existing cluster property: +[source,bash] +---- +curl -X DELETE http://localhost:8983/api/cluster/properties/urlScheme +---- ==== ====== === CLUSTERPROP Parameters -`name`:: +`name` (v1):: + [%autowidth,frame=none] |=== |Optional |Default: none |=== + -The name of the property. +The name of the property. Appears in the path of v2 requests. Supported properties names are `location`, `maxCoresPerNode`, `urlScheme`, and `defaultShardPreferences`. + Other properties can be set (for example, if you need them for custom plugins) but they must begin with the prefix `ext.`. Unknown properties that don't begin with `ext.` will be rejected. -`val`:: +`val` (v1), `value` (v2):: + [%autowidth,frame=none] |=== @@ -329,19 +333,17 @@ V2 API:: ==== [source,bash] ---- -curl -X POST -H 'Content-type:application/json' --data-binary ' +curl -X PUT -H 'Content-type:application/json' --data-binary ' { - "set-obj-property": { - "defaults" : { - "collection": { - "numShards": 2, - "nrtReplicas": 1, - "tlogReplicas": 1, - "pullReplicas": 1 - } + "defaults" : { + "collection": { + "numShards": 2, + "nrtReplicas": 1, + "tlogReplicas": 1, + "pullReplicas": 1 } } -}' http://localhost:8983/api/cluster +}' http://localhost:8983/api/cluster/properties ---- ==== ====== @@ -350,26 +352,30 @@ curl -X POST -H 'Content-type:application/json' --data-binary ' [source,bash] ---- -curl -X POST -H 'Content-type:application/json' --data-binary ' +curl -X PUT -H 'Content-type:application/json' --data-binary ' { - "set-obj-property": { - "defaults" : { - "collection": { - "nrtReplicas": null - } + "defaults" : { + "collection": { + "nrtReplicas": null } } -}' http://localhost:8983/api/cluster +}' http://localhost:8983/api/cluster/properties ---- *Unset all values in `defaults`* [source,bash] ---- -curl -X POST -H 'Content-type:application/json' --data-binary ' -{ "set-obj-property" : { - "defaults" : null -}' http://localhost:8983/api/cluster +curl -X PUT -H 'Content-type:application/json' --data-binary ' +{ + "defaults" : null +}' http://localhost:8983/api/cluster/properties +---- +or +[source,bash] ---- +curl -X DELETE http://localhost:8983/api/cluster/properties/defaults +---- + === Default Shard Preferences @@ -379,17 +385,103 @@ Then, set the value of `defaultShardPreferences` to `node.sysprop:sysprop.YOUR_P [source,bash] ---- -curl -X POST -H 'Content-type:application/json' --data-binary ' +curl -X PUT -H 'Content-type:application/json' --data-binary ' { - "set-property" : { - "name" : "defaultShardPreferences", - "val" : "node.sysprop:sysprop.rack" - } -}' http://localhost:8983/api/cluster + "value" : "node.sysprop:sysprop.rack" +}' http://localhost:8983/api/cluster/properties/defaultShardPreferences ---- At this point, if you run a query on a node having e.g., `rack=rack1`, Solr will try to hit only replicas from `rack1`. + +=== List Cluster Properties + +[tabs#setobjproperty-request] +====== +V1 API:: ++ +==== +There is no V1 equivalent of this action. + +==== +V2 API:: ++ +==== +[source,bash] +---- +curl -X GET http://localhost:8983/api/cluster/properties +---- +==== +====== + +*Input* + +[source,bash] +---- +curl -X GET http://localhost:8983/api/cluster/properties +---- + +*Output* + +[source,json] +---- +{ + "responseHeader": { + "status": 0, + "QTime": 2 + }, + "clusterProperties": [ + "urlScheme", + "defaultShardPreferences" + ] +} +---- + + +=== Fetch Cluster Property + +[tabs#setobjproperty-request] +====== +V1 API:: ++ +==== +There is no V1 equivalent of this action. + +==== +V2 API:: ++ +==== +[source,bash] +---- +curl -X GET http://localhost:8983/api/cluster/properties/urlScheme +---- +==== +====== + +*Input* + +[source,bash] +---- +curl -X GET http://localhost:8983/api/cluster/properties/urlScheme +---- + +*Output* + +[source,json] +---- +{ + "responseHeader": { + "status": 0, + "QTime": 2 + }, + "clusterProperty": { + "name": "urlScheme", + "value": "https" + } +} +---- + + [[balancereplicas]] == Balance Replicas diff --git a/solr/solrj/src/resources/java-template/api.mustache b/solr/solrj/src/resources/java-template/api.mustache index 757335a2b83..c4ef7f9c59b 100644 --- a/solr/solrj/src/resources/java-template/api.mustache +++ b/solr/solrj/src/resources/java-template/api.mustache @@ -133,14 +133,18 @@ public class {{classname}} { {{/requiredParams}} {{#bodyParam}} {{^vendorExtensions.x-genericEntity}} + {{#isMap}} + this.requestBody = new HashMap<>(); + {{/isMap}} {{#isArray}} this.requestBody = new ArrayList<>(); - addHeader("Content-type", "application/json"); {{/isArray}} + {{^isMap}} {{^isArray}} this.requestBody = new {{{dataType}}}(); - addHeader("Content-type", "application/json"); {{/isArray}} + {{/isMap}} + addHeader("Content-type", "application/json"); {{/vendorExtensions.x-genericEntity}} {{/bodyParam}} } From 8de5721645344ffa4a34ea6886fcc9cd3d25b45a Mon Sep 17 00:00:00 2001 From: Andrey Bozhko Date: Thu, 21 Nov 2024 15:52:35 -0600 Subject: [PATCH 15/33] Fix: Avoid NPE if snapshotMgr failed during core init (#2879) --- .../src/java/org/apache/solr/core/SolrCore.java | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/solr/core/src/java/org/apache/solr/core/SolrCore.java b/solr/core/src/java/org/apache/solr/core/SolrCore.java index 55325568abe..749436a0e8c 100644 --- a/solr/core/src/java/org/apache/solr/core/SolrCore.java +++ b/solr/core/src/java/org/apache/solr/core/SolrCore.java @@ -1838,13 +1838,15 @@ private void doClose() { } // Close the snapshots meta-data directory. - Directory snapshotsDir = snapshotMgr.getSnapshotsDir(); - try { - this.directoryFactory.release(snapshotsDir); - } catch (Throwable e) { - log.error("Exception releasing snapshotsDir {}", snapshotsDir, e); - if (e instanceof Error) { - throw (Error) e; + if (snapshotMgr != null) { + Directory snapshotsDir = snapshotMgr.getSnapshotsDir(); + try { + this.directoryFactory.release(snapshotsDir); + } catch (Throwable e) { + log.error("Exception releasing snapshotsDir {}", snapshotsDir, e); + if (e instanceof Error) { + throw (Error) e; + } } } From a4084e899e447a57c4050ce8db9a3aa91588cd02 Mon Sep 17 00:00:00 2001 From: Chris Hostetter Date: Thu, 21 Nov 2024 16:15:09 -0700 Subject: [PATCH 16/33] SOLR-17478: Fix (test only) bug in ZkTestServer --- .../java/org/apache/solr/SolrTestCaseJ4.java | 3 -- .../org/apache/solr/cloud/ZkTestServer.java | 42 ++++++++++++++++++- 2 files changed, 40 insertions(+), 5 deletions(-) diff --git a/solr/test-framework/src/java/org/apache/solr/SolrTestCaseJ4.java b/solr/test-framework/src/java/org/apache/solr/SolrTestCaseJ4.java index 03388397050..d7d67f05ef1 100644 --- a/solr/test-framework/src/java/org/apache/solr/SolrTestCaseJ4.java +++ b/solr/test-framework/src/java/org/apache/solr/SolrTestCaseJ4.java @@ -17,7 +17,6 @@ package org.apache.solr; import static java.util.Objects.requireNonNull; -import static org.apache.solr.cloud.SolrZkServer.ZK_WHITELIST_PROPERTY; import static org.apache.solr.common.cloud.ZkStateReader.HTTPS; import static org.apache.solr.common.cloud.ZkStateReader.URL_SCHEME; import static org.apache.solr.update.processor.DistributingUpdateProcessorFactory.DISTRIB_UPDATE_PARAM; @@ -292,7 +291,6 @@ public static void setupTestCases() { System.setProperty("solr.filterCache.async", String.valueOf(random().nextBoolean())); System.setProperty("solr.http.disableCookies", Boolean.toString(rarely())); - System.setProperty(ZK_WHITELIST_PROPERTY, "*"); startTrackingSearchers(); ignoreException("ignore_exception"); newRandomConfig(); @@ -340,7 +338,6 @@ public static void teardownTestCases() throws Exception { System.clearProperty(URL_SCHEME); System.clearProperty("solr.cloud.wait-for-updates-with-stale-state-pause"); System.clearProperty("solr.zkclienttmeout"); - System.clearProperty(ZK_WHITELIST_PROPERTY); HttpClientUtil.resetHttpClientBuilder(); Http2SolrClient.resetSslContextFactory(); diff --git a/solr/test-framework/src/java/org/apache/solr/cloud/ZkTestServer.java b/solr/test-framework/src/java/org/apache/solr/cloud/ZkTestServer.java index 2041760c0d4..b18f255e8bf 100644 --- a/solr/test-framework/src/java/org/apache/solr/cloud/ZkTestServer.java +++ b/solr/test-framework/src/java/org/apache/solr/cloud/ZkTestServer.java @@ -16,6 +16,9 @@ */ package org.apache.solr.cloud; +import static org.apache.solr.cloud.SolrZkServer.ZK_WHITELIST_PROPERTY; +import static org.junit.Assert.assertTrue; + import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; @@ -57,6 +60,7 @@ import org.apache.zookeeper.server.ServerConfig; import org.apache.zookeeper.server.ZKDatabase; import org.apache.zookeeper.server.ZooKeeperServer; +import org.apache.zookeeper.server.command.FourLetterCommands; import org.apache.zookeeper.server.persistence.FileTxnSnapLog; import org.apache.zookeeper.server.quorum.QuorumPeerConfig.ConfigException; import org.apache.zookeeper.test.ClientBase; @@ -380,7 +384,9 @@ protected void shutdown() throws IOException { try { int port = cnxnFactory.getLocalPort(); if (port > 0) { - ClientBase.waitForServerDown(getZkHost(), 30000); + assertTrue( + "ZK Server did not go down when expected", + ClientBase.waitForServerDown(getZkHost(), 30000)); } } catch (NullPointerException ignored) { // server never successfully started @@ -534,6 +540,8 @@ public void run() throws InterruptedException, IOException { public void run(boolean solrFormat) throws InterruptedException, IOException { log.info("STARTING ZK TEST SERVER"); + ensureStatCommandWhitelisted(); + AtomicReference zooError = new AtomicReference<>(); try { if (zooThread != null) { @@ -596,7 +604,8 @@ public void setClientPort(int clientPort) { } log.info("start zk server on port: {}", port); - ClientBase.waitForServerUp(getZkHost(), 30000); + assertTrue( + "ZK Server did not go up when expected", ClientBase.waitForServerUp(getZkHost(), 30000)); init(solrFormat); } catch (Exception e) { @@ -852,4 +861,33 @@ protected void printLayout() throws Exception { public SolrZkClient getZkClient() { return chRootClient; } + + /** Ensure the {@link ClientBase} helper methods we want to use will work. */ + private static void ensureStatCommandWhitelisted() { + // Use this instead of hardcoding "stat" so we get compile error if ZK removes the command + final String stat = FourLetterCommands.getCommandString(FourLetterCommands.statCmd); + if (!FourLetterCommands.isEnabled(stat)) { + final String original = System.getProperty(ZK_WHITELIST_PROPERTY); + try { + log.error( + "ZkTestServer requires the 'stat' command, temporarily manipulating your whitelist"); + System.setProperty(ZK_WHITELIST_PROPERTY, "*"); + FourLetterCommands.resetWhiteList(); + // This call to isEnabled should force ZK to "re-read" the system property in it's static + // vrs + assertTrue( + "Temporary manipulation of ZK Whitelist didn't work?", + FourLetterCommands.isEnabled(stat)); + } finally { + if (null == original) { + System.clearProperty(ZK_WHITELIST_PROPERTY); + } else { + System.setProperty(ZK_WHITELIST_PROPERTY, original); + } + } + assertTrue( + "Temporary manipulation of ZK Whitelist didn't survive re-setting original value, ZK 4LW init logic has broken this class", + FourLetterCommands.isEnabled(stat)); + } + } } From 621165a94dd5f72cb422abf28ca69aa38e5f5fca Mon Sep 17 00:00:00 2001 From: Eric Pugh Date: Thu, 21 Nov 2024 20:30:07 -0500 Subject: [PATCH 17/33] SOLR-17567: Improve Stream CLI implementation (#2872) Cleanup and adding polish to the Stream CLI tool after getting more eyes on it. More robust handling of comments in .expr files, better use of CLI options, preventing "Strings" from being used to select an Option, in favour of an Option object. --------- Co-authored-by: Christos Malliaridis --- .../commons-cli.commons-cli.all.txt | 16 +++ .../src/java/org/apache/solr/cli/SolrCLI.java | 2 +- .../java/org/apache/solr/cli/StreamTool.java | 43 +++--- .../org/apache/solr/handler/CatStream.java | 7 +- .../org/apache/solr/cli/StreamToolTest.java | 15 ++- .../snapshots/SolrOnHdfsSnapshotsTool.java | 126 +++++++++--------- solr/packaging/test/test_stream.bats | 2 +- .../query-guide/pages/stream-tool.adoc | 44 ++++-- .../client/solrj/io/stream/LetStream.java | 5 - 9 files changed, 152 insertions(+), 108 deletions(-) create mode 100644 gradle/validation/forbidden-apis/commons-cli.commons-cli.all.txt diff --git a/gradle/validation/forbidden-apis/commons-cli.commons-cli.all.txt b/gradle/validation/forbidden-apis/commons-cli.commons-cli.all.txt new file mode 100644 index 00000000000..469fef8238f --- /dev/null +++ b/gradle/validation/forbidden-apis/commons-cli.commons-cli.all.txt @@ -0,0 +1,16 @@ +@defaultMessage Use a org.apache.commons.cli.Option instead of a String value +org.apache.commons.cli.CommandLine#hasOption(java.lang.String) +org.apache.commons.cli.CommandLine#getOptionValue(java.lang.String) +org.apache.commons.cli.CommandLine#getOptionValue(java.lang.String, java.lang.String) +org.apache.commons.cli.CommandLine#getParsedOptionValue(java.lang.String, java.lang.Object) +org.apache.commons.cli.CommandLine#hasOption(char) +org.apache.commons.cli.CommandLine#getOptionValue(char) +org.apache.commons.cli.CommandLine#getOptionValue(char, java.lang.String) +#org.apache.commons.cli.CommandLine#getOptionValue(char, Supplier) +org.apache.commons.cli.CommandLine#getOptionValues(char) +org.apache.commons.cli.CommandLine#getOptionValues(java.lang.String) +org.apache.commons.cli.CommandLine#getParsedOptionValue(char) +# org.apache.commons.cli.CommandLine#getParsedOptionValue(char, Supplier) +org.apache.commons.cli.CommandLine#getParsedOptionValue(char, java.lang.Object) +org.apache.commons.cli.CommandLine#getParsedOptionValue(java.lang.String) +# org.apache.commons.cli.CommandLine#getParsedOptionValue(String, Supplier) diff --git a/solr/core/src/java/org/apache/solr/cli/SolrCLI.java b/solr/core/src/java/org/apache/solr/cli/SolrCLI.java index 32483720d17..15e26ce49c7 100755 --- a/solr/core/src/java/org/apache/solr/cli/SolrCLI.java +++ b/solr/core/src/java/org/apache/solr/cli/SolrCLI.java @@ -231,7 +231,7 @@ private static Tool newTool(String toolType) throws Exception { * CLI option. */ public static String getOptionWithDeprecatedAndDefault( - CommandLine cli, String opt, String deprecated, String def) { + CommandLine cli, Option opt, Option deprecated, String def) { String val = cli.getOptionValue(opt); if (val == null) { val = cli.getOptionValue(deprecated); diff --git a/solr/core/src/java/org/apache/solr/cli/StreamTool.java b/solr/core/src/java/org/apache/solr/cli/StreamTool.java index 6cb6ae81dbb..39684310f0e 100644 --- a/solr/core/src/java/org/apache/solr/cli/StreamTool.java +++ b/solr/core/src/java/org/apache/solr/cli/StreamTool.java @@ -35,6 +35,7 @@ import java.util.HashMap; import java.util.List; import java.util.Locale; +import java.util.Map; import java.util.Set; import org.apache.commons.cli.CommandLine; import org.apache.commons.cli.Option; @@ -77,12 +78,12 @@ public String getName() { @Override public String getUsage() { // Specify that the last argument is the streaming expression - return "bin/solr stream [--array-delimiter ] [-c ] [--delimiter ] [-e ] [-f\n" + return "bin/solr stream [--array-delimiter ] [-c ] [--delimiter ] [--execution ] [--fields\n" + " ] [-h] [--header] [-s ] [-u ] [-v] [-z ] \n"; } private static final Option EXECUTION_OPTION = - Option.builder("e") + Option.builder() .longOpt("execution") .hasArg() .argName("ENVIRONMENT") @@ -100,7 +101,7 @@ public String getUsage() { .build(); private static final Option FIELDS_OPTION = - Option.builder("f") + Option.builder() .longOpt("fields") .argName("FIELDS") .hasArg() @@ -229,11 +230,7 @@ public void runImpl(CommandLine cli) throws Exception { } } } finally { - - if (pushBackStream != null) { - pushBackStream.close(); - } - + pushBackStream.close(); solrClientCache.close(); } @@ -277,7 +274,7 @@ private PushBackStream doLocalMode(CommandLine cli, String expr) throws Exceptio Lang.register(streamFactory); - stream = StreamTool.constructStream(streamFactory, streamExpression); + stream = streamFactory.constructStream(streamExpression); pushBackStream = new PushBackStream(stream); @@ -306,11 +303,11 @@ private PushBackStream doLocalMode(CommandLine cli, String expr) throws Exceptio private PushBackStream doRemoteMode(CommandLine cli, String expr) throws Exception { String solrUrl = CLIUtils.normalizeSolrUrl(cli); - if (!cli.hasOption("name")) { + if (!cli.hasOption(COLLECTION_OPTION)) { throw new IllegalStateException( - "You must provide --name COLLECTION with --worker solr parameter."); + "You must provide --name COLLECTION with --execution remote parameter."); } - String collection = cli.getOptionValue("name"); + String collection = cli.getOptionValue(COLLECTION_OPTION); if (expr.toLowerCase(Locale.ROOT).contains("stdin(")) { throw new IllegalStateException( @@ -371,11 +368,10 @@ public void close() throws IOException { } } - @SuppressWarnings({"unchecked", "rawtypes"}) @Override public Tuple read() throws IOException { String line = reader.readLine(); - HashMap map = new HashMap(); + Map map = new HashMap<>(); Tuple tuple = new Tuple(map); if (line != null) { tuple.put("line", line); @@ -435,11 +431,15 @@ public LocalCatStream(String commaDelimitedFilepaths, int maxLines) { @Override public void setStreamContext(StreamContext context) { - // LocalCatStream has no Solr core to pull from the context + // LocalCatStream inherently has no Solr core to pull from the context } @Override - protected List validateAndSetFilepathsInSandbox(String commaDelimitedFilepaths) { + protected List validateAndSetFilepathsInSandbox() { + // The nature of LocalCatStream is that we are not limited to the sandboxed "userfiles" + // directory + // the way the CatStream does. + final List crawlSeeds = new ArrayList<>(); for (String crawlRootStr : commaDelimitedFilepaths.split(",")) { Path crawlRootPath = Paths.get(crawlRootStr).normalize(); @@ -483,11 +483,6 @@ static String listToString(List values, String internalDelim) { return buf.toString(); } - private static TupleStream constructStream( - StreamFactory streamFactory, StreamExpression streamExpression) throws IOException { - return streamFactory.constructStream(streamExpression); - } - static String readExpression(LineNumberReader bufferedReader, String[] args) throws IOException { StringBuilder exprBuff = new StringBuilder(); @@ -499,17 +494,17 @@ static String readExpression(LineNumberReader bufferedReader, String[] args) thr break; } - if (line.indexOf("/*") == 0) { + if (line.trim().indexOf("/*") == 0) { comment = true; continue; } - if (line.indexOf("*/") == 0) { + if (line.trim().contains("*/")) { comment = false; continue; } - if (comment || line.startsWith("#") || line.startsWith("//")) { + if (comment || line.trim().startsWith("#") || line.trim().startsWith("//")) { continue; } diff --git a/solr/core/src/java/org/apache/solr/handler/CatStream.java b/solr/core/src/java/org/apache/solr/handler/CatStream.java index f2515f9b38b..fdffe29e6c0 100644 --- a/solr/core/src/java/org/apache/solr/handler/CatStream.java +++ b/solr/core/src/java/org/apache/solr/handler/CatStream.java @@ -49,7 +49,7 @@ public class CatStream extends TupleStream implements Expressible { private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass()); - private final String commaDelimitedFilepaths; + protected final String commaDelimitedFilepaths; private final int maxLines; // -1 for no max private StreamContext context; @@ -113,8 +113,7 @@ public List children() { @Override public void open() throws IOException { - final List initialCrawlSeeds = - validateAndSetFilepathsInSandbox(this.commaDelimitedFilepaths); + final List initialCrawlSeeds = validateAndSetFilepathsInSandbox(); final List filesToCrawl = new ArrayList<>(); for (CrawlFile crawlSeed : initialCrawlSeeds) { @@ -164,7 +163,7 @@ public Explanation toExplanation(StreamFactory factory) throws IOException { .withExpression(toExpression(factory).toString()); } - protected List validateAndSetFilepathsInSandbox(String commaDelimitedFilepaths) { + protected List validateAndSetFilepathsInSandbox() { final List crawlSeeds = new ArrayList<>(); for (String crawlRootStr : commaDelimitedFilepaths.split(",")) { Path crawlRootPath = chroot.resolve(crawlRootStr).normalize(); diff --git a/solr/core/src/test/org/apache/solr/cli/StreamToolTest.java b/solr/core/src/test/org/apache/solr/cli/StreamToolTest.java index e91ab9e2d81..926e8aa91e3 100644 --- a/solr/core/src/test/org/apache/solr/cli/StreamToolTest.java +++ b/solr/core/src/test/org/apache/solr/cli/StreamToolTest.java @@ -100,8 +100,15 @@ public void testReadExpression() throws Exception { buf.println("/*"); buf.println("Multi-line comment Comment..."); buf.println("*/"); + buf.println(" /*"); + buf.println("Multi-line comment Comment..."); + buf.println(" */"); + buf.println("/*"); + buf.println("Multi-line comment ending with closing chars... */"); buf.println("// Single line comment"); buf.println("# Single line comment"); + buf.println(" // Single line comment"); + buf.println(" # Single line comment"); buf.println("let(a=$1, b=$2,"); buf.println("search($3))"); buf.println(")"); @@ -227,7 +234,7 @@ public void testStdInFailsWithRemoteWorker() throws Exception { String[] args = new String[] { "stream", - "-e", + "--execution", "remote", "--name", "fakeCollection", @@ -246,7 +253,7 @@ public void testStdInSucceedsWithLocalWorker() throws Exception { String[] args = new String[] { "stream", - "-e", + "--execution", "local", "-v", "-z", @@ -269,7 +276,7 @@ public void testRunEchoStreamLocally() throws Exception { // notice that we do not pass in zkHost or solrUrl for a simple echo run locally. String[] args = { "stream", - "-e", + "--execution", "local", "--verbose", "-zk-host", @@ -313,7 +320,7 @@ public void testRunEchoStreamRemotely() throws Exception { // test passing in the file String[] args = { "stream", - "-e", + "--execution", "remote", "-c", collectionName, diff --git a/solr/modules/hdfs/src/java/org/apache/solr/hdfs/snapshots/SolrOnHdfsSnapshotsTool.java b/solr/modules/hdfs/src/java/org/apache/solr/hdfs/snapshots/SolrOnHdfsSnapshotsTool.java index c0ce936da1d..92c0f73bf5c 100644 --- a/solr/modules/hdfs/src/java/org/apache/solr/hdfs/snapshots/SolrOnHdfsSnapshotsTool.java +++ b/solr/modules/hdfs/src/java/org/apache/solr/hdfs/snapshots/SolrOnHdfsSnapshotsTool.java @@ -35,13 +35,14 @@ import java.util.Optional; import org.apache.commons.cli.CommandLine; import org.apache.commons.cli.CommandLineParser; +import org.apache.commons.cli.DefaultParser; import org.apache.commons.cli.HelpFormatter; import org.apache.commons.cli.Option; import org.apache.commons.cli.Options; import org.apache.commons.cli.ParseException; -import org.apache.commons.cli.PosixParser; import org.apache.hadoop.fs.Path; import org.apache.solr.cli.CLIO; +import org.apache.solr.cli.CommonCLIOptions; import org.apache.solr.client.solrj.SolrServerException; import org.apache.solr.client.solrj.impl.CloudSolrClient; import org.apache.solr.client.solrj.request.CollectionAdminRequest; @@ -61,28 +62,59 @@ * This class provides utility functions required for Solr on HDFS specific snapshots' * functionality. * + *

If HDFS remains in Solr 10, then we should migrate this to extending ToolBase + * *

For general purpose snapshot tooling see the related classes in the {@link * org.apache.solr.cli} package. */ public class SolrOnHdfsSnapshotsTool implements Closeable, CLIO { private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass()); - private static final String PREPARE_FOR_EXPORT = "prepare-snapshot-export"; - private static final String HELP = "help"; - private static final String COLLECTION = "c"; - private static final String TEMP_DIR = "t"; - private static final String DEST_DIR = "d"; - private static final String SOLR_ZK_ENSEMBLE = "z"; - private static final String HDFS_PATH_PREFIX = "p"; + private static final Option PREPARE_FOR_EXPORT_OPTION = + Option.builder() + .longOpt("prepare-snapshot-export") + .hasArg() + .desc( + "The authentication mechanism to enable (basicAuth or kerberos). Defaults to 'basicAuth'.") + .build(); + private static final Option HDFS_PATH_PREFIX_OPTION = + Option.builder("p") + .hasArg() + .desc( + "This parameter specifies the HDFS URI prefix to be used " + + "during snapshot export preparation. This is applicable only if the Solr collection index files are stored on HDFS.") + .build(); + + private static final Option TEMP_DIR_OPTION = + Option.builder("t") + .hasArg() + .desc( + "This parameter specifies the path of a temporary directory on local filesystem" + + " during prepare-snapshot-export command.") + .build(); + private static final Option COLLECTION_OPTION = + Option.builder("c") + .hasArg() + .desc( + "This parameter specifies the name of the collection to be used during snapshot operation") + .build(); + private static final Option DEST_DIR_OPTION = + Option.builder("d") + .hasArg() + .desc( + "This parameter specifies the path on shared file-system (e.g. HDFS) where the snapshot related" + + " information should be stored.") + .build(); + private static final List OPTION_HELP_ORDER = Arrays.asList( - PREPARE_FOR_EXPORT, - HELP, - SOLR_ZK_ENSEMBLE, - COLLECTION, - DEST_DIR, - TEMP_DIR, - HDFS_PATH_PREFIX); + PREPARE_FOR_EXPORT_OPTION.getLongOpt(), + CommonCLIOptions.HELP_OPTION.getOpt(), + CommonCLIOptions.ZK_HOST_OPTION.getOpt(), + COLLECTION_OPTION.getOpt(), + DEST_DIR_OPTION.getOpt(), + TEMP_DIR_OPTION.getOpt(), + HDFS_PATH_PREFIX_OPTION.getOpt()); private final CloudSolrClient solrClient; @@ -248,43 +280,17 @@ public void prepareForExport( } public static void main(String[] args) throws IOException { - CommandLineParser parser = new PosixParser(); + CommandLineParser parser = new DefaultParser(); Options options = new Options(); - options.addOption( - null, - PREPARE_FOR_EXPORT, - true, - "This command will prepare copylistings for the specified snapshot." - + " This command should only be used only if Solr is deployed with Hadoop and collection index files are stored on a shared" - + " file-system e.g. HDFS"); - - options.addOption( - null, - HELP, - false, - "This command will print the help message for the snapshots related commands."); - options.addOption( - TEMP_DIR, - true, - "This parameter specifies the path of a temporary directory on local filesystem" - + " during prepare-snapshot-export command."); - options.addOption( - DEST_DIR, - true, - "This parameter specifies the path on shared file-system (e.g. HDFS) where the snapshot related" - + " information should be stored."); - options.addOption( - COLLECTION, - true, - "This parameter specifies the name of the collection to be used during snapshot operation"); - options.addOption( - SOLR_ZK_ENSEMBLE, true, "This parameter specifies the Solr Zookeeper ensemble address"); - options.addOption( - HDFS_PATH_PREFIX, - true, - "This parameter specifies the HDFS URI prefix to be used" - + " during snapshot export preparation. This is applicable only if the Solr collection index files are stored on HDFS."); + options.addOption(PREPARE_FOR_EXPORT_OPTION); + + options.addOption(CommonCLIOptions.HELP_OPTION); + options.addOption(TEMP_DIR_OPTION); + options.addOption(DEST_DIR_OPTION); + options.addOption(COLLECTION_OPTION); + options.addOption(CommonCLIOptions.ZK_HOST_OPTION); + options.addOption(HDFS_PATH_PREFIX_OPTION); CommandLine cmd = null; try { @@ -295,15 +301,15 @@ public static void main(String[] args) throws IOException { System.exit(1); } - if (cmd.hasOption(PREPARE_FOR_EXPORT)) { + if (cmd.hasOption(PREPARE_FOR_EXPORT_OPTION)) { try (SolrOnHdfsSnapshotsTool tool = - new SolrOnHdfsSnapshotsTool(requiredArg(options, cmd, SOLR_ZK_ENSEMBLE))) { - if (cmd.hasOption(PREPARE_FOR_EXPORT)) { - String snapshotName = cmd.getOptionValue(PREPARE_FOR_EXPORT); - String collectionName = requiredArg(options, cmd, COLLECTION); - String localFsDir = requiredArg(options, cmd, TEMP_DIR); - String hdfsOpDir = requiredArg(options, cmd, DEST_DIR); - String pathPrefix = cmd.getOptionValue(HDFS_PATH_PREFIX); + new SolrOnHdfsSnapshotsTool(requiredArg(options, cmd, CommonCLIOptions.ZK_HOST_OPTION))) { + if (cmd.hasOption(PREPARE_FOR_EXPORT_OPTION)) { + String snapshotName = cmd.getOptionValue(PREPARE_FOR_EXPORT_OPTION); + String collectionName = requiredArg(options, cmd, COLLECTION_OPTION); + String localFsDir = requiredArg(options, cmd, TEMP_DIR_OPTION); + String hdfsOpDir = requiredArg(options, cmd, DEST_DIR_OPTION); + String pathPrefix = cmd.getOptionValue(HDFS_PATH_PREFIX_OPTION); if (pathPrefix != null) { try { @@ -320,7 +326,7 @@ public static void main(String[] args) throws IOException { tool.prepareForExport(collectionName, snapshotName, localFsDir, pathPrefix, hdfsOpDir); } } - } else if (cmd.hasOption(HELP)) { + } else if (cmd.hasOption(CommonCLIOptions.HELP_OPTION)) { printHelp(options); } else { CLIO.out("Unknown command specified."); @@ -328,7 +334,7 @@ public static void main(String[] args) throws IOException { } } - private static String requiredArg(Options options, CommandLine cmd, String optVal) { + private static String requiredArg(Options options, CommandLine cmd, Option optVal) { if (!cmd.hasOption(optVal)) { CLIO.out("Please specify the value for option " + optVal); printHelp(options); diff --git a/solr/packaging/test/test_stream.bats b/solr/packaging/test/test_stream.bats index b2f5072a3d8..2043d9c0c32 100644 --- a/solr/packaging/test/test_stream.bats +++ b/solr/packaging/test/test_stream.bats @@ -62,7 +62,7 @@ teardown() { echo 'sort="price desc"' >> "${solr_stream_file}" echo ')' >> "${solr_stream_file}" - run solr stream -e remote --name techproducts --solr-url http://localhost:${SOLR_PORT} --header --credentials name:password ${solr_stream_file} + run solr stream --name techproducts --solr-url http://localhost:${SOLR_PORT} --header --credentials name:password ${solr_stream_file} assert_output --partial 'name price' assert_output --partial 'CORSAIR XMS' diff --git a/solr/solr-ref-guide/modules/query-guide/pages/stream-tool.adoc b/solr/solr-ref-guide/modules/query-guide/pages/stream-tool.adoc index 20fe2458e42..acb5d6964e7 100644 --- a/solr/solr-ref-guide/modules/query-guide/pages/stream-tool.adoc +++ b/solr/solr-ref-guide/modules/query-guide/pages/stream-tool.adoc @@ -27,17 +27,17 @@ To run it, open a terminal and enter: [,console] ---- -$ bin/solr stream --header -c techproducts --delimiter=\| 'search(techproducts,q="name:memory",fl="name,price")' +$ bin/solr stream -c techproducts --header --fields price,name --delimiter=\| 'search(techproducts,q="iPod",fl="name,price")' ---- This will run the provided streaming expression on the `techproducts` collection on your local Solr and produce: [,console] ---- -name|price -CORSAIR XMS 2GB (2 x 1GB) 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) Dual Channel Kit System Memory - Retail|185.0 -CORSAIR ValueSelect 1GB 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) System Memory - Retail|74.99 -A-DATA V-Series 1GB 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) System Memory - OEM| +price|name +11.5|iPod & iPod Mini USB 2.0 Cable +19.95|Belkin Mobile Power Cord for iPod w/ Dock +399.0|Apple 60 GB iPod with Video Playback Black ---- TIP: Notice how we used the pipe character (|) as the delimiter? It required a backslash for escaping it so it wouldn't be treated as a pipe within the shell script. @@ -50,14 +50,23 @@ Assuming you have create the file `stream.expr` with the contents: ---- # Stream a search +/* + You can have + multi-line comments as well. +*/ + search( techproducts, q="name:memory", fl="name,price", sort="price desc" ) + +// the end ---- +Notice the various ways to format comments in the file? + Then you can run it on the Solr collection `techproducts`, specifying you want a header row: [,console] @@ -83,7 +92,7 @@ The `--help` (or simply `-h`) option will output information on its usage (i.e., [source,plain] ---- -usage: bin/solr stream [--array-delimiter ] [-c ] [--delimiter ] [-e ] [-f +usage: bin/solr stream [--array-delimiter ] [-c ] [--delimiter ] [--execution ] [--fields ] [-h] [--header] [-s ] [-u ] [-v] [-z ] List of options: @@ -91,9 +100,9 @@ List of options: -c,--name Name of the specific collection to execute expression on if the execution is set to 'remote'. Required for 'remote' execution environment. --delimiter The output delimiter. Default to using three spaces. - -e,--execution Execution environment is either 'local' (i.e CLI process) or via a 'remote' Solr + --execution Execution environment is either 'local' (i.e CLI process) or via a 'remote' Solr server. Default environment is 'remote'. - -f,--fields The fields in the tuples to output. Defaults to fields in the first tuple of result + --fields The fields in the tuples to output. Defaults to fields in the first tuple of result set. -h,--help Print this message. --header Specify to include a header line. @@ -173,4 +182,21 @@ $ bin/solr stream -c techproducts 'echo("$1")' "Hello World" Hello World ---- -This also works when using `.expr` files. +This also works when using `.expr` files. You can nest as many variables you want. +Here is an example of passing in both the file and the number of lines to process: + +---- +# Index CSV File + +update( + gettingstarted, + parseCSV( + cat($1, maxLines=$2) + ) +) +---- + +[,console] +---- +$ bin/solr stream -c techproducts file.expr ./example/exampledocs/books.csv 10 +---- diff --git a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/LetStream.java b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/LetStream.java index be95e2271a3..d05942a1593 100644 --- a/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/LetStream.java +++ b/solr/solrj-streaming/src/java/org/apache/solr/client/solrj/io/stream/LetStream.java @@ -222,9 +222,4 @@ public StreamComparator getStreamSort() { public int getCost() { return 0; } - - @SuppressWarnings({"rawtypes"}) - public Map getLetParams() { - return this.letParams; - } } From 620175a5626e69823b5aec8e20734a6352195000 Mon Sep 17 00:00:00 2001 From: Eric Pugh Date: Fri, 22 Nov 2024 06:58:31 -0500 Subject: [PATCH 18/33] SOLR-17556: Examples should run with the standard & recommended Solr home and solr data dir (#2861) * Have techproducts, films, and schemaless all start in the normal solr home. Only -e cloud generates it's individual node files in ./example/cloud/node1, node2 etc... * Update the ref guide to consistently use -Dsolr.modules settings instead of relying on on the declaration. --------- Co-authored-by: Houston Putman --- solr/CHANGES.txt | 2 + .../org/apache/solr/cli/RunExampleTool.java | 19 +++---- .../solr/cli/TestSolrCLIRunExample.java | 9 --- solr/server/resources/log4j2-console.xml | 4 +- solr/server/resources/log4j2.xml | 4 +- .../configsets/_default/conf/solrconfig.xml | 45 --------------- .../conf/solrconfig.xml | 55 ------------------- .../query-guide/pages/learning-to-rank.adoc | 2 +- .../query-guide/pages/result-clustering.adoc | 2 +- 9 files changed, 17 insertions(+), 125 deletions(-) diff --git a/solr/CHANGES.txt b/solr/CHANGES.txt index ea10c72378b..666958c64da 100644 --- a/solr/CHANGES.txt +++ b/solr/CHANGES.txt @@ -247,6 +247,8 @@ led to the suppression of exceptions. (Andrey Bozhko) * SOLR-17504: CoreContainer calls UpdateHandler.commit when closing a read-only core (Bruno Roustant) +* SOLR-17556: "home" and "data" directories used by Solr examples have been updated to align with documented best practices. (Eric Pugh, Houston Putman) + ================== 9.7.1 ================== Bug Fixes --------------------- diff --git a/solr/core/src/java/org/apache/solr/cli/RunExampleTool.java b/solr/core/src/java/org/apache/solr/cli/RunExampleTool.java index fff3c04f5c5..4f0346c6079 100644 --- a/solr/core/src/java/org/apache/solr/cli/RunExampleTool.java +++ b/solr/core/src/java/org/apache/solr/cli/RunExampleTool.java @@ -46,7 +46,6 @@ import org.apache.commons.io.FileUtils; import org.apache.solr.client.solrj.SolrClient; import org.apache.solr.client.solrj.impl.CloudSolrClient; -import org.apache.solr.client.solrj.impl.Http2SolrClient; import org.apache.solr.common.SolrException; import org.noggit.CharArr; import org.noggit.JSONWriter; @@ -266,7 +265,6 @@ public void runImpl(CommandLine cli) throws Exception { } protected void runExample(CommandLine cli, String exampleName) throws Exception { - File exDir = setupExampleDir(serverDir, exampleDir, exampleName); String collectionName = "schemaless".equals(exampleName) ? "gettingstarted" : exampleName; String configSet = "techproducts".equals(exampleName) ? "sample_techproducts_configs" : "_default"; @@ -277,9 +275,9 @@ protected void runExample(CommandLine cli, String exampleName) throws Exception Integer.parseInt( cli.getOptionValue(PORT_OPTION, System.getenv().getOrDefault("SOLR_PORT", "8983"))); Map nodeStatus = - startSolr(new File(exDir, "solr"), isCloudMode, cli, port, zkHost, 30); + startSolr(new File(serverDir, "solr"), isCloudMode, cli, port, zkHost, 30); - String solrUrl = (String) nodeStatus.get("baseUrl"); + String solrUrl = CLIUtils.normalizeSolrUrl((String) nodeStatus.get("baseUrl")); // If the example already exists then let the user know they should delete it, or // they may get unusual behaviors. @@ -310,7 +308,7 @@ protected void runExample(CommandLine cli, String exampleName) throws Exception echo( "You may want to run 'bin/solr delete -c " + collectionName - + "' first before running the example to ensure a fresh state."); + + " --delete-config' first before running the example to ensure a fresh state."); } if (!alreadyExists) { @@ -333,7 +331,7 @@ protected void runExample(CommandLine cli, String exampleName) throws Exception if ("techproducts".equals(exampleName) && !alreadyExists) { - File exampledocsDir = new File(exampleDir, "exampledocs"); + File exampledocsDir = new File(this.exampleDir, "exampledocs"); if (!exampledocsDir.isDirectory()) { File readOnlyExampleDir = new File(serverDir.getParentFile(), "example"); if (readOnlyExampleDir.isDirectory()) { @@ -364,7 +362,9 @@ protected void runExample(CommandLine cli, String exampleName) throws Exception "exampledocs directory not found, skipping indexing step for the techproducts example"); } } else if ("films".equals(exampleName) && !alreadyExists) { - try (SolrClient solrClient = new Http2SolrClient.Builder(solrUrl).build()) { + try (SolrClient solrClient = + CLIUtils.getSolrClient( + solrUrl, cli.getOptionValue(CommonCLIOptions.CREDENTIALS_OPTION))) { echo("Adding dense vector field type to films schema"); SolrCLI.postJsonToSolr( solrClient, @@ -424,7 +424,7 @@ protected void runExample(CommandLine cli, String exampleName) throws Exception + " }\n" + " }\n"); - File filmsJsonFile = new File(exampleDir, "films/films.json"); + File filmsJsonFile = new File(this.exampleDir, "films/films.json"); echo("Indexing films example docs from " + filmsJsonFile.getAbsolutePath()); String[] args = new String[] { @@ -549,8 +549,7 @@ protected void runCloudExample(CommandLine cli) throws Exception { new File(cloudDir, "node" + (n + 1) + "/solr"), true, cli, cloudPorts[n], zkHost, 30); } - String solrUrl = (String) nodeStatus.get("baseUrl"); - if (solrUrl.endsWith("/")) solrUrl = solrUrl.substring(0, solrUrl.length() - 1); + String solrUrl = CLIUtils.normalizeSolrUrl((String) nodeStatus.get("baseUrl"), false); // wait until live nodes == numNodes waitToSeeLiveNodes(zkHost, numNodes); diff --git a/solr/core/src/test/org/apache/solr/cli/TestSolrCLIRunExample.java b/solr/core/src/test/org/apache/solr/cli/TestSolrCLIRunExample.java index da279a12301..6da81edaa29 100644 --- a/solr/core/src/test/org/apache/solr/cli/TestSolrCLIRunExample.java +++ b/solr/core/src/test/org/apache/solr/cli/TestSolrCLIRunExample.java @@ -403,15 +403,6 @@ protected void testExample(String exampleName) throws Exception { // dump all the output written by the SolrCLI commands to stdout // System.out.println("\n\n"+toolOutput+"\n\n"); - File exampleSolrHomeDir = new File(solrExampleDir, exampleName + "/solr"); - assertTrue( - exampleSolrHomeDir.getAbsolutePath() - + " not found! run " - + exampleName - + " example failed; output: " - + toolOutput, - exampleSolrHomeDir.isDirectory()); - if ("techproducts".equals(exampleName)) { try (SolrClient solrClient = getHttpSolrClient("http://localhost:" + bindPort + "/solr", exampleName)) { diff --git a/solr/server/resources/log4j2-console.xml b/solr/server/resources/log4j2-console.xml index c33c93c9327..2d5b8690bf6 100644 --- a/solr/server/resources/log4j2-console.xml +++ b/solr/server/resources/log4j2-console.xml @@ -16,9 +16,9 @@ limitations under the License. --> - - + diff --git a/solr/server/resources/log4j2.xml b/solr/server/resources/log4j2.xml index 006de0c965c..f5b373338b7 100644 --- a/solr/server/resources/log4j2.xml +++ b/solr/server/resources/log4j2.xml @@ -16,7 +16,7 @@ limitations under the License. --> - + @@ -62,7 +62,7 @@ - + diff --git a/solr/server/solr/configsets/_default/conf/solrconfig.xml b/solr/server/solr/configsets/_default/conf/solrconfig.xml index 5bc2cf13415..3cec6a4e578 100644 --- a/solr/server/solr/configsets/_default/conf/solrconfig.xml +++ b/solr/server/solr/configsets/_default/conf/solrconfig.xml @@ -37,51 +37,6 @@ --> 9.11 - - - - - - - - 9.11 - - - - - - - - - - - - - - - - - - - ${tests.luceneMatchVersion:LATEST} - - - ${solr.data.dir:} - - - - - - - - true - - - - - - - - - - - - - - commit - - - http://127.0.0.1:TEST_PORT/solr/collection1 - 00:00:01 - COMPRESSION - - - - - - - max-age=30, public - - - - diff --git a/solr/core/src/test/org/apache/solr/handler/TestReplicationHandler.java b/solr/core/src/test/org/apache/solr/handler/TestReplicationHandler.java index 14714b64c26..b30e20f70bf 100644 --- a/solr/core/src/test/org/apache/solr/handler/TestReplicationHandler.java +++ b/solr/core/src/test/org/apache/solr/handler/TestReplicationHandler.java @@ -78,7 +78,6 @@ import org.apache.solr.util.TimeOut; import org.junit.After; import org.junit.Before; -import org.junit.BeforeClass; import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -103,14 +102,6 @@ public class TestReplicationHandler extends SolrTestCaseJ4 { // index from previous test method static int nDocs = 500; - /* For testing backward compatibility, remove for 10.x */ - private static boolean useLegacyParams = false; - - @BeforeClass - public static void beforeClass() { - useLegacyParams = rarely(); - } - @Override @Before public void setUp() throws Exception { @@ -388,38 +379,6 @@ public void doTestDetails() throws Exception { } } - @Test - public void testLegacyConfiguration() throws Exception { - SolrInstance solrInstance = null; - JettySolrRunner instanceJetty = null; - SolrClient client = null; - try { - solrInstance = - new SolrInstance( - createTempDir("solr-instance").toFile(), - "replication-legacy", - leaderJetty.getLocalPort()); - solrInstance.setUp(); - instanceJetty = createAndStartJetty(solrInstance); - client = - ReplicationTestHelper.createNewSolrClient( - buildUrl(instanceJetty.getLocalPort()), DEFAULT_TEST_CORENAME); - - NamedList details = getDetails(client); - - assertEquals("repeater isLeader?", "true", details.get("isLeader")); - assertEquals("repeater isFollower?", "true", details.get("isFollower")); - assertNotNull("repeater has leader section", details.get("leader")); - assertNotNull("repeater has follower section", details.get("follower")); - - } finally { - if (instanceJetty != null) { - instanceJetty.stop(); - } - if (client != null) client.close(); - } - } - /** * Verify that empty commits and/or commits with openSearcher=false on the leader do not cause * subsequent replication problems on the follower @@ -779,11 +738,8 @@ private NamedList getFollowerDetails() throws SolrServerException, IOExc ModifiableSolrParams params = new ModifiableSolrParams(); params.set(CommonParams.QT, "/replication"); params.set("command", "details"); - if (useLegacyParams) { - params.set("slave", "true"); - } else { - params.set("follower", "true"); - } + params.set("follower", "true"); + QueryResponse response = followerClient.query(params); // details/follower/timesIndexReplicated @@ -825,9 +781,6 @@ public void doTestIndexFetchWithLeaderUrl() throws Exception { assertEquals(nDocs, leaderQueryResult.getNumFound()); String urlKey = "leaderUrl"; - if (useLegacyParams) { - urlKey = "masterUrl"; - } // index fetch String leaderUrl = @@ -1667,48 +1620,6 @@ public void testEmptyBackups() throws Exception { } } - public void testGetBoolWithBackwardCompatibility() { - assertTrue(ReplicationHandler.getBoolWithBackwardCompatibility(params(), "foo", "bar", true)); - assertFalse(ReplicationHandler.getBoolWithBackwardCompatibility(params(), "foo", "bar", false)); - assertTrue( - ReplicationHandler.getBoolWithBackwardCompatibility( - params("foo", "true"), "foo", "bar", false)); - assertTrue( - ReplicationHandler.getBoolWithBackwardCompatibility( - params("bar", "true"), "foo", "bar", false)); - assertTrue( - ReplicationHandler.getBoolWithBackwardCompatibility( - params("foo", "true", "bar", "false"), "foo", "bar", false)); - } - - public void testGetObjectWithBackwardCompatibility() { - assertEquals( - "aaa", - ReplicationHandler.getObjectWithBackwardCompatibility(params(), "foo", "bar", "aaa")); - assertEquals( - "bbb", - ReplicationHandler.getObjectWithBackwardCompatibility( - params("foo", "bbb"), "foo", "bar", "aaa")); - assertEquals( - "bbb", - ReplicationHandler.getObjectWithBackwardCompatibility( - params("bar", "bbb"), "foo", "bar", "aaa")); - assertEquals( - "bbb", - ReplicationHandler.getObjectWithBackwardCompatibility( - params("foo", "bbb", "bar", "aaa"), "foo", "bar", "aaa")); - assertNull(ReplicationHandler.getObjectWithBackwardCompatibility(params(), "foo", "bar", null)); - } - - public void testGetObjectWithBackwardCompatibilityFromNL() { - NamedList nl = new NamedList<>(); - assertNull(ReplicationHandler.getObjectWithBackwardCompatibility(nl, "foo", "bar")); - nl.add("bar", "bbb"); - assertEquals("bbb", ReplicationHandler.getObjectWithBackwardCompatibility(nl, "foo", "bar")); - nl.add("foo", "aaa"); - assertEquals("aaa", ReplicationHandler.getObjectWithBackwardCompatibility(nl, "foo", "bar")); - } - private static class AddExtraDocs implements Runnable { SolrClient leaderClient; diff --git a/solr/solr-ref-guide/modules/upgrade-notes/pages/major-changes-in-solr-10.adoc b/solr/solr-ref-guide/modules/upgrade-notes/pages/major-changes-in-solr-10.adoc index 33440aec93b..97942e989c1 100644 --- a/solr/solr-ref-guide/modules/upgrade-notes/pages/major-changes-in-solr-10.adoc +++ b/solr/solr-ref-guide/modules/upgrade-notes/pages/major-changes-in-solr-10.adoc @@ -85,3 +85,5 @@ Please note this also removes the ability to share resource intensive objects ac * The language specific Response Writers, which were deprecated in 9.8 in favour of more widely used formats like JSON have been removed. The removed writer types (invoked as part of the `wt` parameter) include `python`, `ruby`, `php`, and `phps`. + +* The deprecated support for configuring replication using master/slave terminology is removed. Use leader/follower. From 3e358911be52f3725832d8a303d0d4846cd674e3 Mon Sep 17 00:00:00 2001 From: David Smiley Date: Tue, 3 Dec 2024 00:08:15 +0100 Subject: [PATCH 29/33] SOLR-17568: SolrCloud shouldn't proxy/route a core specific request (#2885) Because cores are a node level concept, not a cluster one. This also removed a loop over all collections. CLI ExportTool should have been contacting the correct node but wasn't. Use RandomIterator utility. --- solr/CHANGES.txt | 5 +- .../java/org/apache/solr/api/V2HttpCall.java | 2 +- .../java/org/apache/solr/cli/ExportTool.java | 4 +- .../org/apache/solr/servlet/HttpSolrCall.java | 76 +++++-------------- .../pages/major-changes-in-solr-10.adoc | 6 ++ .../AbstractBasicDistributedZk2TestBase.java | 16 +--- 6 files changed, 32 insertions(+), 77 deletions(-) diff --git a/solr/CHANGES.txt b/solr/CHANGES.txt index a7a5ef5683c..9a5f4aae64b 100644 --- a/solr/CHANGES.txt +++ b/solr/CHANGES.txt @@ -36,7 +36,8 @@ Improvements Optimizations --------------------- -(No changes) +* SOLR-17568: The CLI bin/solr export tool now contacts the appropriate nodes directly for data instead of proxying through one. + (David Smiley) Bug Fixes --------------------- @@ -132,6 +133,8 @@ Other Changes * SOLR-16903: Update CLI tools to use java.nio.file.Path instead of java.io.File (Andrey Bozhko) +* SOLR-17568: SolrCloud no longer reroutes/proxies a core request to another node if not found locally. (David Smiley) + ================== 9.8.0 ================== New Features --------------------- diff --git a/solr/core/src/java/org/apache/solr/api/V2HttpCall.java b/solr/core/src/java/org/apache/solr/api/V2HttpCall.java index 6912af39510..d156710a675 100644 --- a/solr/core/src/java/org/apache/solr/api/V2HttpCall.java +++ b/solr/core/src/java/org/apache/solr/api/V2HttpCall.java @@ -165,7 +165,7 @@ public void call(SolrQueryRequest req, SolrQueryResponse rsp) { core = getCoreByCollection(collectionName, isPreferLeader); if (core == null) { // this collection exists , but this node does not have a replica for that collection - extractRemotePath(collectionName, collectionName); + extractRemotePath(collectionName); if (action == REMOTEQUERY) { action = ADMIN_OR_REMOTEQUERY; coreUrl = coreUrl.replace("/solr/", "/solr/____v2/c/"); diff --git a/solr/core/src/java/org/apache/solr/cli/ExportTool.java b/solr/core/src/java/org/apache/solr/cli/ExportTool.java index 59bca949dc1..b5a58377ba3 100644 --- a/solr/core/src/java/org/apache/solr/cli/ExportTool.java +++ b/solr/core/src/java/org/apache/solr/cli/ExportTool.java @@ -660,8 +660,8 @@ class CoreHandler { } boolean exportDocsFromCore() throws IOException, SolrServerException { - - try (SolrClient client = CLIUtils.getSolrClient(baseurl, credentials)) { + // reference the replica's node URL, not the baseUrl in scope, which could be anywhere + try (SolrClient client = CLIUtils.getSolrClient(replica.getBaseUrl(), credentials)) { expectedDocs = getDocCount(replica.getCoreName(), client, query); QueryRequest request; ModifiableSolrParams params = new ModifiableSolrParams(); diff --git a/solr/core/src/java/org/apache/solr/servlet/HttpSolrCall.java b/solr/core/src/java/org/apache/solr/servlet/HttpSolrCall.java index 7241be77390..1e6c9f42e29 100644 --- a/solr/core/src/java/org/apache/solr/servlet/HttpSolrCall.java +++ b/solr/core/src/java/org/apache/solr/servlet/HttpSolrCall.java @@ -40,7 +40,6 @@ import java.lang.invoke.MethodHandles; import java.nio.charset.StandardCharsets; import java.util.ArrayList; -import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.Enumeration; @@ -279,7 +278,7 @@ protected void init() throws Exception { } else { // if we couldn't find it locally, look on other nodes if (idx > 0) { - extractRemotePath(collectionName, origCorename); + extractRemotePath(collectionName); if (action == REMOTEQUERY) { path = path.substring(idx); return; @@ -462,10 +461,10 @@ protected void extractHandlerFromURLPath(SolrRequestParsers parser) throws Excep } } - protected void extractRemotePath(String collectionName, String origCorename) + protected void extractRemotePath(String collectionName) throws KeeperException, InterruptedException, SolrException { assert core == null; - coreUrl = getRemoteCoreUrl(collectionName, origCorename); + coreUrl = getRemoteCoreUrl(collectionName); // don't proxy for internal update requests invalidStates = checkStateVersionsAreValid(queryParams.get(CloudSolrClient.STATE_VERSION)); if (coreUrl != null @@ -1090,39 +1089,16 @@ private SolrCore checkProps(ZkNodeProps zkProps) { return core; } - private List getSlicesForAllCollections(ClusterState clusterState, boolean activeSlices) { - // looks across *all* collections - if (activeSlices) { - return clusterState - .collectionStream() - .flatMap(coll -> Arrays.stream(coll.getActiveSlicesArr())) - .toList(); - } else { - return clusterState.collectionStream().flatMap(coll -> coll.getSlices().stream()).toList(); - } - } - - protected String getRemoteCoreUrl(String collectionName, String origCorename) - throws SolrException { + protected String getRemoteCoreUrl(String collectionName) throws SolrException { ClusterState clusterState = cores.getZkController().getClusterState(); final DocCollection docCollection = clusterState.getCollectionOrNull(collectionName); - Slice[] slices = (docCollection != null) ? docCollection.getActiveSlicesArr() : null; - List activeSlices; - boolean byCoreName = false; + if (docCollection == null) { + return null; + } + Collection activeSlices = docCollection.getActiveSlices(); int totalReplicas = 0; - if (slices == null) { - byCoreName = true; - // all collections! - activeSlices = getSlicesForAllCollections(clusterState, true); - if (activeSlices.isEmpty()) { - activeSlices = getSlicesForAllCollections(clusterState, false); - } - } else { - activeSlices = List.of(slices); - } - for (Slice s : activeSlices) { totalReplicas += s.getReplicas().size(); } @@ -1145,48 +1121,30 @@ protected String getRemoteCoreUrl(String collectionName, String origCorename) "No active replicas found for collection: " + collectionName); } - String coreUrl = - getCoreUrl(collectionName, origCorename, clusterState, activeSlices, byCoreName, true); + String coreUrl = getCoreUrl(activeSlices, true, clusterState.getLiveNodes()); if (coreUrl == null) { - coreUrl = - getCoreUrl(collectionName, origCorename, clusterState, activeSlices, byCoreName, false); + coreUrl = getCoreUrl(activeSlices, false, clusterState.getLiveNodes()); } return coreUrl; } private String getCoreUrl( - String collectionName, - String origCorename, - ClusterState clusterState, - List slices, - boolean byCoreName, - boolean activeReplicas) { - String coreUrl; - Set liveNodes = clusterState.getLiveNodes(); + Collection slices, boolean activeReplicas, Set liveNodes) { - List shuffledSlices; - if (slices.size() < 2) { - shuffledSlices = slices; - } else { - shuffledSlices = new ArrayList<>(slices); - Collections.shuffle(shuffledSlices, Utils.RANDOM); - } + Iterator shuffledSlices = new RandomIterator<>(Utils.RANDOM, slices); + while (shuffledSlices.hasNext()) { + Slice slice = shuffledSlices.next(); - for (Slice slice : shuffledSlices) { - List randomizedReplicas = new ArrayList<>(slice.getReplicas()); - Collections.shuffle(randomizedReplicas, Utils.RANDOM); + Iterator shuffledReplicas = new RandomIterator<>(Utils.RANDOM, slice.getReplicas()); + while (shuffledReplicas.hasNext()) { + Replica replica = shuffledReplicas.next(); - for (Replica replica : randomizedReplicas) { if (!activeReplicas || (liveNodes.contains(replica.getNodeName()) && replica.getState() == Replica.State.ACTIVE)) { - if (byCoreName && !Objects.equals(origCorename, replica.getStr(CORE_NAME_PROP))) { - // if it's by core name, make sure they match - continue; - } if (Objects.equals(replica.getBaseUrl(), cores.getZkController().getBaseUrl())) { // don't count a local core continue; diff --git a/solr/solr-ref-guide/modules/upgrade-notes/pages/major-changes-in-solr-10.adoc b/solr/solr-ref-guide/modules/upgrade-notes/pages/major-changes-in-solr-10.adoc index 97942e989c1..2d1902a02fa 100644 --- a/solr/solr-ref-guide/modules/upgrade-notes/pages/major-changes-in-solr-10.adoc +++ b/solr/solr-ref-guide/modules/upgrade-notes/pages/major-changes-in-solr-10.adoc @@ -60,6 +60,12 @@ Users who previously relied on collection-specific URLs to avoid including the c The service installer now installs a `systemd` startup script instead of an `init.d` startup script. It is up to the user to uninstall any existing `init.d` script when upgrading. +=== SolrCloud request routing + +HTTP requests to SolrCloud that are for a specific core must be delivered to the node with that core, or else an HTTP 404 Not Found response will occur. +Previously, SolrCloud would try too hard scanning the cluster's state to look for it and internally route/proxy it. +If only one node is exposed to a client, and if the client uses the bin/solr export tool, it probably won't work. + === Deprecation removals * The `jaegertracer-configurator` module, which was deprecated in 9.2, is removed. Users should migrate to the `opentelemetry` module. diff --git a/solr/test-framework/src/java/org/apache/solr/cloud/AbstractBasicDistributedZk2TestBase.java b/solr/test-framework/src/java/org/apache/solr/cloud/AbstractBasicDistributedZk2TestBase.java index 513596533ff..1ac793e852d 100644 --- a/solr/test-framework/src/java/org/apache/solr/cloud/AbstractBasicDistributedZk2TestBase.java +++ b/solr/test-framework/src/java/org/apache/solr/cloud/AbstractBasicDistributedZk2TestBase.java @@ -204,25 +204,13 @@ private void addAndQueryDocs(final String baseUrl, int docs) throws Exception { SolrQuery query = new SolrQuery("*:*"); - String collectionUrl = baseUrl + "/onenodecollection" + "core"; - try (SolrClient client = getHttpSolrClient(baseUrl, "onenodecollectioncore")) { - - // it might take a moment for the proxy node to see us in their cloud state - waitForNon403or404or503(client, collectionUrl); - + try (SolrClient client = getHttpSolrClient(baseUrl, "onenodecollection")) { // add a doc - SolrInputDocument doc = new SolrInputDocument(); - doc.addField("id", docs); - client.add(doc); + client.add(sdoc("id", docs)); client.commit(); QueryResponse results = client.query(query); assertEquals(docs - 1, results.getResults().getNumFound()); - } - - try (SolrClient client = getHttpSolrClient(baseUrl, "onenodecollection")) { - QueryResponse results = client.query(query); - assertEquals(docs - 1, results.getResults().getNumFound()); SolrInputDocument doc = new SolrInputDocument(); doc.addField("id", docs + 1); From 83391964df5b01839329be44fb31a030864770c1 Mon Sep 17 00:00:00 2001 From: Bruno Roustant <33934988+bruno-roustant@users.noreply.github.com> Date: Wed, 4 Dec 2024 11:23:26 +0100 Subject: [PATCH 30/33] SOLR-17574: Move host allow list cache to AllowListUrlChecker. (#2892) --- solr/CHANGES.txt | 2 + .../solr/security/AllowListUrlChecker.java | 36 ++++++++++++-- .../component/TestShardHandlerFactory.java | 17 ------- .../security/AllowListUrlCheckerTest.java | 48 +++++++++++++++++++ .../solr/common/cloud/ClusterState.java | 27 +++-------- 5 files changed, 89 insertions(+), 41 deletions(-) diff --git a/solr/CHANGES.txt b/solr/CHANGES.txt index 9a5f4aae64b..68b61331a79 100644 --- a/solr/CHANGES.txt +++ b/solr/CHANGES.txt @@ -234,6 +234,8 @@ Bug Fixes * SOLR-17575: Fixed broken backwards compatibility with the legacy "langid.whitelist" config in Solr Langid. (Jan Høydahl, Alexander Zagniotov) +* SOLR-17574: Fix AllowListUrlChecker when liveNodes changes. Remove ClusterState.getHostAllowList (Bruno Roustant, David Smiley) + Dependency Upgrades --------------------- (No changes) diff --git a/solr/core/src/java/org/apache/solr/security/AllowListUrlChecker.java b/solr/core/src/java/org/apache/solr/security/AllowListUrlChecker.java index 9bcede9b060..9fbffc4cdfb 100644 --- a/solr/core/src/java/org/apache/solr/security/AllowListUrlChecker.java +++ b/solr/core/src/java/org/apache/solr/security/AllowListUrlChecker.java @@ -27,6 +27,7 @@ import java.util.Set; import java.util.regex.Matcher; import java.util.regex.Pattern; +import java.util.stream.Collectors; import org.apache.solr.common.SolrException; import org.apache.solr.common.cloud.ClusterState; import org.apache.solr.core.NodeConfig; @@ -85,6 +86,9 @@ public String toString() { /** Allow list of hosts. Elements in the list will be host:port (no protocol or context). */ private final Set hostAllowList; + private volatile Set liveHostUrlsCache; + private volatile Set liveNodesCache; + /** * @param urlAllowList List of allowed URLs. URLs must be well-formed, missing protocol is * tolerated. An empty list means there is no explicit allow-list of URLs, in this case no URL @@ -136,11 +140,10 @@ public void checkAllowList(List urls) throws MalformedURLException { */ public void checkAllowList(List urls, ClusterState clusterState) throws MalformedURLException { - Set clusterHostAllowList = - clusterState == null ? Collections.emptySet() : clusterState.getHostAllowList(); + Set liveHostUrls = getLiveHostUrls(clusterState); for (String url : urls) { String hostPort = parseHostPort(url); - if (clusterHostAllowList.stream().noneMatch(hostPort::equalsIgnoreCase) + if (liveHostUrls.stream().noneMatch(hostPort::equalsIgnoreCase) && hostAllowList.stream().noneMatch(hostPort::equalsIgnoreCase)) { throw new SolrException( SolrException.ErrorCode.FORBIDDEN, @@ -154,6 +157,33 @@ public void checkAllowList(List urls, ClusterState clusterState) } } + /** + * Gets the set of live hosts urls (host:port) built from the set of live nodes. The set is cached + * to be reused until the live nodes change. + */ + private Set getLiveHostUrls(ClusterState clusterState) { + if (clusterState == null) { + return Set.of(); + } + if (liveHostUrlsCache == null || clusterState.getLiveNodes() != liveNodesCache) { + synchronized (this) { + Set liveNodes = clusterState.getLiveNodes(); + if (liveHostUrlsCache == null || liveNodes != liveNodesCache) { + liveHostUrlsCache = buildLiveHostUrls(liveNodes); + liveNodesCache = liveNodes; + } + } + } + return liveHostUrlsCache; + } + + @VisibleForTesting + Set buildLiveHostUrls(Set liveNodes) { + return liveNodes.stream() + .map((liveNode) -> liveNode.substring(0, liveNode.indexOf('_'))) + .collect(Collectors.toSet()); + } + /** Whether this checker has been created with a non-empty allow-list of URLs. */ public boolean hasExplicitAllowList() { return !hostAllowList.isEmpty(); diff --git a/solr/core/src/test/org/apache/solr/handler/component/TestShardHandlerFactory.java b/solr/core/src/test/org/apache/solr/handler/component/TestShardHandlerFactory.java index 541d2d845f3..970fa7bb48a 100644 --- a/solr/core/src/test/org/apache/solr/handler/component/TestShardHandlerFactory.java +++ b/solr/core/src/test/org/apache/solr/handler/component/TestShardHandlerFactory.java @@ -17,21 +17,16 @@ package org.apache.solr.handler.component; import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.CoreMatchers.hasItem; import static org.hamcrest.CoreMatchers.instanceOf; -import static org.hamcrest.CoreMatchers.is; import java.nio.file.Path; import java.util.ArrayList; import java.util.Arrays; -import java.util.HashMap; import java.util.HashSet; import java.util.List; -import java.util.Set; import org.apache.solr.SolrTestCaseJ4; import org.apache.solr.client.solrj.impl.LBSolrClient; import org.apache.solr.client.solrj.request.QueryRequest; -import org.apache.solr.common.cloud.ClusterState; import org.apache.solr.common.params.CommonParams; import org.apache.solr.common.params.ModifiableSolrParams; import org.apache.solr.common.params.ShardParams; @@ -155,18 +150,6 @@ public void getShardsAllowList() { } } - @Test - public void testLiveNodesToHostUrl() { - Set liveNodes = - new HashSet<>(Arrays.asList("1.2.3.4:8983_solr", "1.2.3.4:9000_", "1.2.3.4:9001_solr-2")); - ClusterState cs = new ClusterState(liveNodes, new HashMap<>()); - Set hostSet = cs.getHostAllowList(); - assertThat(hostSet.size(), is(3)); - assertThat(hostSet, hasItem("1.2.3.4:8983")); - assertThat(hostSet, hasItem("1.2.3.4:9000")); - assertThat(hostSet, hasItem("1.2.3.4:9001")); - } - @Test public void testXML() { Path home = TEST_PATH(); diff --git a/solr/core/src/test/org/apache/solr/security/AllowListUrlCheckerTest.java b/solr/core/src/test/org/apache/solr/security/AllowListUrlCheckerTest.java index b32c2124c15..0a4f57ba5af 100644 --- a/solr/core/src/test/org/apache/solr/security/AllowListUrlCheckerTest.java +++ b/solr/core/src/test/org/apache/solr/security/AllowListUrlCheckerTest.java @@ -24,11 +24,14 @@ import java.net.MalformedURLException; import java.util.Arrays; import java.util.Collections; +import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Set; +import java.util.concurrent.atomic.AtomicInteger; import org.apache.solr.SolrTestCaseJ4; import org.apache.solr.common.SolrException; +import org.apache.solr.common.cloud.ClusterState; import org.junit.Test; /** Tests {@link AllowListUrlChecker}. */ @@ -196,6 +199,51 @@ public void testHostParsingNoProtocol() throws Exception { equalTo(AllowListUrlChecker.parseHostPorts(urls("https://abc-1.com:8983/solr")))); } + @Test + public void testLiveNodesToHostUrlCache() throws Exception { + // Given some live nodes defined in the cluster state. + Set liveNodes = Set.of("1.2.3.4:8983_solr", "1.2.3.4:9000_", "1.2.3.4:9001_solr-2"); + ClusterState clusterState1 = new ClusterState(liveNodes, new HashMap<>()); + + // When we call the AllowListUrlChecker.checkAllowList method on both valid and invalid urls. + AtomicInteger callCount = new AtomicInteger(); + AllowListUrlChecker checker = + new AllowListUrlChecker(List.of()) { + @Override + Set buildLiveHostUrls(Set liveNodes) { + callCount.incrementAndGet(); + return super.buildLiveHostUrls(liveNodes); + } + }; + for (int i = 0; i < 3; i++) { + checker.checkAllowList( + List.of("1.2.3.4:8983", "1.2.3.4:9000", "1.2.3.4:9001"), clusterState1); + SolrException exception = + expectThrows( + SolrException.class, + () -> checker.checkAllowList(List.of("1.1.3.4:8983"), clusterState1)); + assertThat(exception.code(), equalTo(SolrException.ErrorCode.FORBIDDEN.code)); + } + // Then we verify that the AllowListUrlChecker caches the live host urls and only builds them + // once. + assertThat(callCount.get(), equalTo(1)); + + // And when the ClusterState live nodes change. + liveNodes = Set.of("2.3.4.5:8983_solr", "2.3.4.5:9000_", "2.3.4.5:9001_solr-2"); + ClusterState clusterState2 = new ClusterState(liveNodes, new HashMap<>()); + for (int i = 0; i < 3; i++) { + checker.checkAllowList( + List.of("2.3.4.5:8983", "2.3.4.5:9000", "2.3.4.5:9001"), clusterState2); + SolrException exception = + expectThrows( + SolrException.class, + () -> checker.checkAllowList(List.of("1.1.3.4:8983"), clusterState2)); + assertThat(exception.code(), equalTo(SolrException.ErrorCode.FORBIDDEN.code)); + } + // Then the AllowListUrlChecker rebuilds the cache of live host urls. + assertThat(callCount.get(), equalTo(2)); + } + private static List urls(String... urls) { return Arrays.asList(urls); } diff --git a/solr/solrj/src/java/org/apache/solr/common/cloud/ClusterState.java b/solr/solrj/src/java/org/apache/solr/common/cloud/ClusterState.java index 19bfc2565d6..22e1005ed8b 100644 --- a/solr/solrj/src/java/org/apache/solr/common/cloud/ClusterState.java +++ b/solr/solrj/src/java/org/apache/solr/common/cloud/ClusterState.java @@ -34,7 +34,6 @@ import java.util.concurrent.atomic.AtomicInteger; import java.util.function.Consumer; import java.util.function.Function; -import java.util.stream.Collectors; import java.util.stream.Stream; import org.apache.solr.common.MapWriter; import org.apache.solr.common.SolrException; @@ -53,6 +52,8 @@ * Immutable state of the cloud. Normally you can get the state by using {@code * ZkStateReader#getClusterState()}. * + *

However, the {@link #setLiveNodes list of live nodes} is updated when nodes go up and down. + * * @lucene.experimental */ public class ClusterState implements MapWriter { @@ -63,8 +64,7 @@ public class ClusterState implements MapWriter { private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass()); private final Map collectionStates, immutableCollectionStates; - private Set liveNodes; - private Set hostAllowList; + private volatile Set liveNodes; /** Use this constr when ClusterState is meant for consumption. */ public ClusterState(Set liveNodes, Map collectionStates) { @@ -85,8 +85,7 @@ private static Map getRefMap(Map c * loaded (parameter order different from constructor above to have different erasures) */ public ClusterState(Map collectionStates, Set liveNodes) { - this.liveNodes = CollectionUtil.newHashSet(liveNodes.size()); - this.liveNodes.addAll(liveNodes); + setLiveNodes(liveNodes); this.collectionStates = new LinkedHashMap<>(collectionStates); this.immutableCollectionStates = Collections.unmodifiableMap(this.collectionStates); } @@ -189,7 +188,7 @@ public Map getCollectionsMap() { /** Get names of the currently live nodes. */ public Set getLiveNodes() { - return Collections.unmodifiableSet(liveNodes); + return liveNodes; } @Deprecated @@ -387,7 +386,7 @@ public boolean equals(Object obj) { /** Internal API used only by ZkStateReader */ void setLiveNodes(Set liveNodes) { - this.liveNodes = liveNodes; + this.liveNodes = Set.copyOf(liveNodes); } /** @@ -401,20 +400,6 @@ public Map getCollectionStates() { return immutableCollectionStates; } - /** - * Gets the set of allowed hosts (host:port) built from the set of live nodes. The set is cached - * to be reused. - */ - public Set getHostAllowList() { - if (hostAllowList == null) { - hostAllowList = - getLiveNodes().stream() - .map((liveNode) -> liveNode.substring(0, liveNode.indexOf('_'))) - .collect(Collectors.toSet()); - } - return hostAllowList; - } - /** * Streams the resolved {@link DocCollection}s, which will often fetch from ZooKeeper for each one * for a many-collection scenario. Use this sparingly; some users have thousands of collections! From c1062d9406ca17b8500f346f0acde8370a70b96d Mon Sep 17 00:00:00 2001 From: Jason Gerlowski Date: Wed, 4 Dec 2024 10:10:02 -0500 Subject: [PATCH 31/33] SOLR-16781: Remove solrconfig.xml directives (#2875) Solr offers a number of ways for users to add JARs and resources to their classpath, including: * solr.xml entries * SOLR_MODULES env-var/support * core and install-level "lib/" directories * the package manager * direct classpath modification In addition to being largely redundant with the methods above, solrconfig.xml's directive has been a pain point and source of security concerns in the past. This commit removes it from Solr 10. --- solr/CHANGES.txt | 4 ++ .../org/apache/solr/cli/RunExampleTool.java | 8 ++- .../apache/solr/core/ConfigSetService.java | 9 ++- .../java/org/apache/solr/core/SolrConfig.java | 71 ++++--------------- .../handler/designer/SchemaDesignerAPI.java | 2 +- .../SchemaDesignerConfigSetHelper.java | 4 +- .../collection1/conf/solrconfig-test-misc.xml | 6 -- .../with-lib-directive/managed-schema.xml | 25 ------- .../upload/with-lib-directive/solrconfig.xml | 53 -------------- .../apache/solr/cloud/TestConfigSetsAPI.java | 42 ----------- .../apache/solr/core/TestConfLoadPerf.java | 2 +- .../test/org/apache/solr/core/TestConfig.java | 14 ---- .../apache/solr/core/TestMinimalConfig.java | 3 +- .../schema/TestManagedSchemaThreadSafety.java | 3 +- solr/example/README.md | 12 ---- .../solr/collection1/conf/solrconfig-ltr.xml | 3 - .../pages/config-sets.adoc | 2 +- .../pages/configsets-api.adoc | 2 - .../pages/configuring-solr-xml.adoc | 5 +- .../pages/configuring-solrconfig-xml.adoc | 1 - .../configuration-guide/pages/libs.adoc | 29 -------- .../pages/resource-loading.adoc | 5 -- .../pages/solr-modules.adoc | 5 -- .../pages/update-request-processors.adoc | 2 +- .../rule-based-authorization-plugin.adoc | 1 - .../pages/indexing-with-tika.adoc | 9 +-- .../query-guide/pages/learning-to-rank.adoc | 19 ++--- .../pages/major-changes-in-solr-10.adoc | 4 ++ .../pages/major-changes-in-solr-9.adoc | 2 +- 29 files changed, 48 insertions(+), 299 deletions(-) delete mode 100644 solr/core/src/test-files/solr/configsets/upload/with-lib-directive/managed-schema.xml delete mode 100644 solr/core/src/test-files/solr/configsets/upload/with-lib-directive/solrconfig.xml diff --git a/solr/CHANGES.txt b/solr/CHANGES.txt index 68b61331a79..2fec97d6129 100644 --- a/solr/CHANGES.txt +++ b/solr/CHANGES.txt @@ -96,6 +96,10 @@ Deprecation Removals * SOLR-17576: Remove deprecated master/slave option language from ReplicationHandler. (Eric Pugh) +* SOLR-16781: Support for `` directives (used in solrconfig.xml to add JARs on a core-by-core basis) has been removed. Users + looking for similar functionality can use Solr's package manager. Users that don't need to vary JAR access on a per-core basis + have many options, including the `` tag and directly modifying Solr's classpath prior to JVM startup. (Jason Gerlowski) + Dependency Upgrades --------------------- (No changes) diff --git a/solr/core/src/java/org/apache/solr/cli/RunExampleTool.java b/solr/core/src/java/org/apache/solr/cli/RunExampleTool.java index 783d58e0a57..50c0162881a 100644 --- a/solr/core/src/java/org/apache/solr/cli/RunExampleTool.java +++ b/solr/core/src/java/org/apache/solr/cli/RunExampleTool.java @@ -647,6 +647,11 @@ protected Map startSolr( if (!isWindows && cwdPath.length() > 1 && solrHome.startsWith(cwdPath)) solrHome = solrHome.substring(cwdPath.length() + 1); + final var syspropArg = + ("techproducts".equals(cli.getOptionValue(EXAMPLE_OPTION))) + ? "-Dsolr.modules=clustering,extraction,langid,ltr,scripting -Dsolr.ltr.enabled=true -Dsolr.clustering.enabled=true" + : ""; + String startCmd = String.format( Locale.ROOT, @@ -661,7 +666,8 @@ protected Map startSolr( forceArg, verboseArg, extraArgs, - jvmOptsArg); + jvmOptsArg, + syspropArg); startCmd = startCmd.replaceAll("\\s+", " ").trim(); // for pretty printing echo("\nStarting up Solr on port " + port + " using command:"); diff --git a/solr/core/src/java/org/apache/solr/core/ConfigSetService.java b/solr/core/src/java/org/apache/solr/core/ConfigSetService.java index 53160cd75ee..a9f9b417abf 100644 --- a/solr/core/src/java/org/apache/solr/core/ConfigSetService.java +++ b/solr/core/src/java/org/apache/solr/core/ConfigSetService.java @@ -272,7 +272,7 @@ public final ConfigSet loadConfigSet(CoreDescriptor dcore) { NamedList properties = loadConfigSetProperties(dcore, coreLoader); boolean trusted = isConfigSetTrusted(coreLoader); - SolrConfig solrConfig = createSolrConfig(dcore, coreLoader, trusted); + SolrConfig solrConfig = createSolrConfig(dcore, coreLoader); return new ConfigSet( configSetName(dcore), solrConfig, @@ -314,13 +314,12 @@ public ConfigSetService(SolrResourceLoader loader, boolean shareSchema) { * * @param cd the core's CoreDescriptor * @param loader the core's resource loader - * @param isTrusted is the configset trusted? * @return a SolrConfig object */ - protected SolrConfig createSolrConfig( - CoreDescriptor cd, SolrResourceLoader loader, boolean isTrusted) throws IOException { + protected SolrConfig createSolrConfig(CoreDescriptor cd, SolrResourceLoader loader) + throws IOException { return SolrConfig.readFromResourceLoader( - loader, cd.getConfigName(), isTrusted, cd.getSubstitutableProperties()); + loader, cd.getConfigName(), cd.getSubstitutableProperties()); } /** diff --git a/solr/core/src/java/org/apache/solr/core/SolrConfig.java b/solr/core/src/java/org/apache/solr/core/SolrConfig.java index b3c95a23fe7..e7adaf8d2f6 100644 --- a/solr/core/src/java/org/apache/solr/core/SolrConfig.java +++ b/solr/core/src/java/org/apache/solr/core/SolrConfig.java @@ -17,7 +17,6 @@ package org.apache.solr.core; import static org.apache.solr.common.params.CommonParams.NAME; -import static org.apache.solr.common.params.CommonParams.PATH; import static org.apache.solr.core.ConfigOverlay.ZNODEVER; import static org.apache.solr.core.SolrConfig.PluginOpts.LAZY; import static org.apache.solr.core.SolrConfig.PluginOpts.MULTI_OK; @@ -31,7 +30,6 @@ import java.io.InputStream; import java.io.InputStreamReader; import java.lang.invoke.MethodHandles; -import java.net.MalformedURLException; import java.net.URL; import java.nio.file.Files; import java.nio.file.Path; @@ -96,7 +94,7 @@ /** * Provides a static reference to a Config object modeling the main configuration data for a Solr - * instance -- typically found in "solrconfig.xml". + * core -- typically found in "solrconfig.xml". */ public class SolrConfig implements MapSerializable { @@ -143,16 +141,13 @@ public enum PluginOpts { * @param name the configuration name used by the loader if the stream is null */ public SolrConfig(Path instanceDir, String name) throws IOException { - this(new SolrResourceLoader(instanceDir), name, true, null); + this(new SolrResourceLoader(instanceDir), name, null); } public static SolrConfig readFromResourceLoader( - SolrResourceLoader loader, - String name, - boolean isConfigsetTrusted, - Properties substitutableProperties) { + SolrResourceLoader loader, String name, Properties substitutableProperties) { try { - return new SolrConfig(loader, name, isConfigsetTrusted, substitutableProperties); + return new SolrConfig(loader, name, substitutableProperties); } catch (Exception e) { String resource; if (loader instanceof ZkSolrResourceLoader) { @@ -196,15 +191,9 @@ public InputStream apply(String s) { * * @param loader the resource loader * @param name the configuration name - * @param isConfigsetTrusted false if configset was uploaded using unsecured configset upload API, - * true otherwise * @param substitutableProperties optional properties to substitute into the XML */ - private SolrConfig( - SolrResourceLoader loader, - String name, - boolean isConfigsetTrusted, - Properties substitutableProperties) { + private SolrConfig(SolrResourceLoader loader, String name, Properties substitutableProperties) { this.resourceLoader = loader; this.resourceName = name; this.substituteProperties = substitutableProperties; @@ -237,7 +226,7 @@ private SolrConfig( rootDataHashCode = this.root.txt().hashCode(); getRequestParams(); - initLibs(loader, isConfigsetTrusted); + initLibs(loader); String val = root.child( IndexSchema.LUCENE_MATCH_VERSION_PARAM, @@ -934,11 +923,10 @@ public PluginInfo getPluginInfo(String type) { SolrException.ErrorCode.SERVER_ERROR, "Multiple plugins configured for type: " + type); } - private void initLibs(SolrResourceLoader loader, boolean isConfigsetTrusted) { + private void initLibs(SolrResourceLoader loader) { // TODO Want to remove SolrResourceLoader.getInstancePath; it can be on a Standalone subclass. // For Zk subclass, it's needed for the time being as well. We could remove that one if we - // remove two things in SolrCloud: (1) instancePath/lib and (2) solrconfig lib directives with - // relative paths. Can wait till 9.0. + // remove "instancePath/lib" in SolrCloud. Can wait till 9.0. Path instancePath = loader.getInstancePath(); List urls = new ArrayList<>(); @@ -950,48 +938,15 @@ private void initLibs(SolrResourceLoader loader, boolean isConfigsetTrusted) { log.warn("Couldn't add files from {} to classpath: {}", libPath, e); } } - - List nodes = root.getAll("lib"); - if (nodes != null && nodes.size() > 0) { - if (!isConfigsetTrusted) { - throw new SolrException( - ErrorCode.UNAUTHORIZED, - "The configset for this collection was uploaded without any authentication in place," - + " and use of is not available for collections with untrusted configsets. To use this component, re-upload the configset" - + " after enabling authentication and authorization."); - } - - for (int i = 0; i < nodes.size(); i++) { - ConfigNode node = nodes.get(i); - String baseDir = node.attr("dir"); - String path = node.attr(PATH); - if (null != baseDir) { - // :TODO: add support for a simpler 'glob' mutually exclusive of regex - Path dir = instancePath.resolve(baseDir); - String regex = node.attr("regex"); - try { - if (regex == null) urls.addAll(SolrResourceLoader.getURLs(dir)); - else urls.addAll(SolrResourceLoader.getFilteredURLs(dir, regex)); - } catch (IOException e) { - log.warn("Couldn't add files from {} filtered by {} to classpath: {}", dir, regex, e); - } - } else if (null != path) { - final Path dir = instancePath.resolve(path); - try { - urls.add(dir.toUri().toURL()); - } catch (MalformedURLException e) { - log.warn("Couldn't add file {} to classpath: {}", dir, e); - } - } else { - throw new RuntimeException("lib: missing mandatory attributes: 'dir' or 'path'"); - } - } - } - if (!urls.isEmpty()) { loader.addToClassLoader(urls); loader.reloadLuceneSPI(); } + + List nodes = root.getAll("lib"); + if (nodes != null && nodes.size() > 0) { + log.warn(" entries no longer supported in solrconfig.xml; ignoring..."); + } } public int getMultipartUploadLimitKB() { diff --git a/solr/core/src/java/org/apache/solr/handler/designer/SchemaDesignerAPI.java b/solr/core/src/java/org/apache/solr/handler/designer/SchemaDesignerAPI.java index f34793aa744..1370c775540 100644 --- a/solr/core/src/java/org/apache/solr/handler/designer/SchemaDesignerAPI.java +++ b/solr/core/src/java/org/apache/solr/handler/designer/SchemaDesignerAPI.java @@ -254,7 +254,7 @@ public void updateFileContents(SolrQueryRequest req, SolrQueryResponse rsp) try { InMemoryResourceLoader loader = new InMemoryResourceLoader(coreContainer, mutableId, SOLR_CONFIG_XML, data); - SolrConfig.readFromResourceLoader(loader, SOLR_CONFIG_XML, requestIsTrusted, null); + SolrConfig.readFromResourceLoader(loader, SOLR_CONFIG_XML, null); } catch (Exception exc) { updateFileError = exc; } diff --git a/solr/core/src/java/org/apache/solr/handler/designer/SchemaDesignerConfigSetHelper.java b/solr/core/src/java/org/apache/solr/handler/designer/SchemaDesignerConfigSetHelper.java index 0b14b0d4cf4..955aa1d98a9 100644 --- a/solr/core/src/java/org/apache/solr/handler/designer/SchemaDesignerConfigSetHelper.java +++ b/solr/core/src/java/org/apache/solr/handler/designer/SchemaDesignerConfigSetHelper.java @@ -677,9 +677,7 @@ ManagedIndexSchema deleteNestedDocsFieldsIfNeeded(ManagedIndexSchema schema, boo SolrConfig loadSolrConfig(String configSet) { ZkSolrResourceLoader zkLoader = zkLoaderForConfigSet(configSet); - boolean trusted = isConfigSetTrusted(configSet); - - return SolrConfig.readFromResourceLoader(zkLoader, SOLR_CONFIG_XML, trusted, null); + return SolrConfig.readFromResourceLoader(zkLoader, SOLR_CONFIG_XML, null); } ManagedIndexSchema loadLatestSchema(String configSet) { diff --git a/solr/core/src/test-files/solr/collection1/conf/solrconfig-test-misc.xml b/solr/core/src/test-files/solr/collection1/conf/solrconfig-test-misc.xml index 1020db8319e..cbfe9752574 100644 --- a/solr/core/src/test-files/solr/collection1/conf/solrconfig-test-misc.xml +++ b/solr/core/src/test-files/solr/collection1/conf/solrconfig-test-misc.xml @@ -28,12 +28,6 @@ - - - - - - prefix-${solr.test.sys.prop2}-suffix diff --git a/solr/core/src/test-files/solr/configsets/upload/with-lib-directive/managed-schema.xml b/solr/core/src/test-files/solr/configsets/upload/with-lib-directive/managed-schema.xml deleted file mode 100644 index 25a37e6eee3..00000000000 --- a/solr/core/src/test-files/solr/configsets/upload/with-lib-directive/managed-schema.xml +++ /dev/null @@ -1,25 +0,0 @@ - - - - - - - - - - diff --git a/solr/core/src/test-files/solr/configsets/upload/with-lib-directive/solrconfig.xml b/solr/core/src/test-files/solr/configsets/upload/with-lib-directive/solrconfig.xml deleted file mode 100644 index 315bfffbf6c..00000000000 --- a/solr/core/src/test-files/solr/configsets/upload/with-lib-directive/solrconfig.xml +++ /dev/null @@ -1,53 +0,0 @@ - - - - - - - - - ${solr.data.dir:} - - - - ${tests.luceneMatchVersion:LATEST} - - - - - - explicit - true - text - - - - - - - diff --git a/solr/core/src/test/org/apache/solr/cloud/TestConfigSetsAPI.java b/solr/core/src/test/org/apache/solr/cloud/TestConfigSetsAPI.java index b41d698ac4c..01614b7218e 100644 --- a/solr/core/src/test/org/apache/solr/cloud/TestConfigSetsAPI.java +++ b/solr/core/src/test/org/apache/solr/cloud/TestConfigSetsAPI.java @@ -1421,48 +1421,6 @@ public void testUploadWithScriptUpdateProcessor() throws Exception { scriptRequest("newcollection2"); } - @Test - public void testUploadWithLibDirective() throws Exception { - final String untrustedSuffix = "-untrusted"; - uploadConfigSetWithAssertions("with-lib-directive", untrustedSuffix, null); - // try to create a collection with the uploaded configset - ignoreException("without any authentication in place"); - Throwable thrown = - expectThrows( - SolrClient.RemoteSolrException.class, - () -> { - createCollection( - "newcollection3", - "with-lib-directive" + untrustedSuffix, - 1, - 1, - cluster.getSolrClient()); - }); - unIgnoreException("without any authentication in place"); - - assertThat(thrown.getMessage(), containsString("Underlying core creation failed")); - - // Authorization on - final String trustedSuffix = "-trusted"; - uploadConfigSetWithAssertions("with-lib-directive", trustedSuffix, "solr"); - // try to create a collection with the uploaded configset - CollectionAdminResponse resp = - createCollection( - "newcollection3", "with-lib-directive" + trustedSuffix, 1, 1, cluster.getSolrClient()); - - SolrInputDocument doc = sdoc("id", "4055", "subject", "Solr"); - cluster.getSolrClient().add("newcollection3", doc); - cluster.getSolrClient().commit("newcollection3"); - assertEquals( - "4055", - cluster - .getSolrClient() - .query("newcollection3", params("q", "*:*")) - .getResults() - .get(0) - .get("id")); - } - @Test public void testUploadWithForbiddenContent() throws Exception { // Uploads a config set containing a script, a class file and jar file, will return 400 error diff --git a/solr/core/src/test/org/apache/solr/core/TestConfLoadPerf.java b/solr/core/src/test/org/apache/solr/core/TestConfLoadPerf.java index ee9177b2105..4c348104b35 100644 --- a/solr/core/src/test/org/apache/solr/core/TestConfLoadPerf.java +++ b/solr/core/src/test/org/apache/solr/core/TestConfLoadPerf.java @@ -84,7 +84,7 @@ public InputStream openResource(String resource) throws IOException { long startTime = System.currentTimeMillis(); int numReads = 100; for (int i = 0; i < numReads; i++) { - allConfigs.add(SolrConfig.readFromResourceLoader(srl, "solrconfig.xml", true, null)); + allConfigs.add(SolrConfig.readFromResourceLoader(srl, "solrconfig.xml", null)); } assertEquals(numReads, allConfigs.size()); System.gc(); diff --git a/solr/core/src/test/org/apache/solr/core/TestConfig.java b/solr/core/src/test/org/apache/solr/core/TestConfig.java index 2c17cbf1e1a..745fa21c4c5 100644 --- a/solr/core/src/test/org/apache/solr/core/TestConfig.java +++ b/solr/core/src/test/org/apache/solr/core/TestConfig.java @@ -45,20 +45,6 @@ public static void beforeClass() throws Exception { public void testLib() throws IOException { SolrResourceLoader loader = h.getCore().getResourceLoader(); InputStream data = null; - String[] expectedFiles = - new String[] { - "empty-file-main-lib.txt", - "empty-file-a1.txt", - "empty-file-a2.txt", - "empty-file-b1.txt", - "empty-file-b2.txt", - "empty-file-c1.txt" - }; - for (String f : expectedFiles) { - data = loader.openResource(f); - assertNotNull("Should have found file " + f, data); - data.close(); - } String[] unexpectedFiles = new String[] {"empty-file-c2.txt", "empty-file-d2.txt"}; for (String f : unexpectedFiles) { data = null; diff --git a/solr/core/src/test/org/apache/solr/core/TestMinimalConfig.java b/solr/core/src/test/org/apache/solr/core/TestMinimalConfig.java index 1efa74d2d03..b04420664e8 100644 --- a/solr/core/src/test/org/apache/solr/core/TestMinimalConfig.java +++ b/solr/core/src/test/org/apache/solr/core/TestMinimalConfig.java @@ -29,8 +29,7 @@ public static void beforeClass() throws Exception { initCore("solrconfig-minimal.xml", "schema-minimal.xml"); } - // Make sure the content of the lib/ core subfolder is loaded even if there is no node in - // the solrconfig + // Make sure the content of the lib/ core subfolder is loaded @Test public void testLib() throws IOException { SolrResourceLoader loader = h.getCore().getResourceLoader(); diff --git a/solr/core/src/test/org/apache/solr/schema/TestManagedSchemaThreadSafety.java b/solr/core/src/test/org/apache/solr/schema/TestManagedSchemaThreadSafety.java index bd452178f63..2cc881cecc2 100644 --- a/solr/core/src/test/org/apache/solr/schema/TestManagedSchemaThreadSafety.java +++ b/solr/core/src/test/org/apache/solr/schema/TestManagedSchemaThreadSafety.java @@ -183,8 +183,7 @@ private Runnable indexSchemaLoader(String configsetName, final ZkController zkCo try { SolrResourceLoader loader = new ZkSolrResourceLoader(loaderPath, configsetName, null, zkController); - SolrConfig solrConfig = - SolrConfig.readFromResourceLoader(loader, "solrconfig.xml", true, null); + SolrConfig solrConfig = SolrConfig.readFromResourceLoader(loader, "solrconfig.xml", null); ManagedIndexSchemaFactory factory = new ManagedIndexSchemaFactory(); factory.init(new NamedList<>()); diff --git a/solr/example/README.md b/solr/example/README.md index 09bb2dfb277..f0c8e46a4be 100644 --- a/solr/example/README.md +++ b/solr/example/README.md @@ -73,18 +73,6 @@ For a list of other tutorials and introductory articles. Notes About These Examples -------------------------- -### References to Jar Files Outside This Directory - -Various example SolrHome dirs contained in this directory may use "" -statements in the solrconfig.xml file to reference plugin jars outside of -this directory for loading modules via relative paths. - -If you make a copy of this example server and wish to use the -ExtractingRequestHandler (SolrCell), the clustering component, -or any other modules, you will need to -copy the required jars or update the paths to those jars in your -solrconfig.xml. - ### Logging By default, Jetty & Solr will log to the console and logs/solr.log. This can diff --git a/solr/modules/ltr/src/test-files/solr/collection1/conf/solrconfig-ltr.xml b/solr/modules/ltr/src/test-files/solr/collection1/conf/solrconfig-ltr.xml index b863d61728c..c20ee2026f6 100644 --- a/solr/modules/ltr/src/test-files/solr/collection1/conf/solrconfig-ltr.xml +++ b/solr/modules/ltr/src/test-files/solr/collection1/conf/solrconfig-ltr.xml @@ -16,9 +16,6 @@ - - - diff --git a/solr/solr-ref-guide/modules/configuration-guide/pages/config-sets.adoc b/solr/solr-ref-guide/modules/configuration-guide/pages/config-sets.adoc index 57707e94c6e..b44c8a82825 100644 --- a/solr/solr-ref-guide/modules/configuration-guide/pages/config-sets.adoc +++ b/solr/solr-ref-guide/modules/configuration-guide/pages/config-sets.adoc @@ -39,7 +39,7 @@ The Configsets API has some other operations as well, and likewise, so does the To upload a file to a configset already stored on ZooKeeper, you can use xref:deployment-guide:solr-control-script-reference.adoc#copy-between-local-files-and-zookeeper-znodes[`bin/solr zk cp`]. CAUTION: By default, ZooKeeper's file size limit is 1MB. -If your files are larger than this, you'll need to either xref:deployment-guide:zookeeper-ensemble.adoc#increasing-the-file-size-limit[increase the ZooKeeper file size limit] or store them xref:libs.adoc#lib-directives-in-solrconfig[on the filesystem] of every node in a cluster. +If your files are larger than this, you'll need to either xref:deployment-guide:zookeeper-ensemble.adoc#increasing-the-file-size-limit[increase the ZooKeeper file size limit] or store them xref:libs.adoc[on the filesystem] of every node in a cluster. === Forbidden File Types diff --git a/solr/solr-ref-guide/modules/configuration-guide/pages/configsets-api.adoc b/solr/solr-ref-guide/modules/configuration-guide/pages/configsets-api.adoc index 45987271de6..1a5dc43fe48 100644 --- a/solr/solr-ref-guide/modules/configuration-guide/pages/configsets-api.adoc +++ b/solr/solr-ref-guide/modules/configuration-guide/pages/configsets-api.adoc @@ -97,8 +97,6 @@ Upon creation of a collection using an "untrusted" configset, the following func * The XSLT transformer (`tr` parameter) cannot be used at request processing time. * If specified in the configset, the ScriptUpdateProcessorFactory will not initialize. -* Collections won't initialize if directives are used in the configset. -(Note: Libraries added to Solr's classpath don't need the directive) If you use any of these parameters or features, you must have enabled security features in your Solr installation and you must upload the configset as an authenticated user. diff --git a/solr/solr-ref-guide/modules/configuration-guide/pages/configuring-solr-xml.adoc b/solr/solr-ref-guide/modules/configuration-guide/pages/configuring-solr-xml.adoc index 549753d5f3a..13c90737ffe 100644 --- a/solr/solr-ref-guide/modules/configuration-guide/pages/configuring-solr-xml.adoc +++ b/solr/solr-ref-guide/modules/configuration-guide/pages/configuring-solr-xml.adoc @@ -253,8 +253,7 @@ Note that specifying `sharedLib` will not remove `$SOLR_HOME/lib` from Solr's cl + Takes a list of bundled xref:solr-modules.adoc[] to enable on startup. This way of adding modules will add them to the shared class loader, making them -available to every collection in Solr, unlike `` tag in `solrconfig.xml` which is only -for that one collection. Example value: `extracting,ltr`. See the +available to every collection in Solr. Example value: `extracting,ltr`. See the xref:solr-modules.adoc[Solr Modules] chapter for more details. `allowPaths`:: @@ -506,7 +505,7 @@ Optional parameter to provide a compression implementation for state.json over t |=== + The class to use for logging. -The corresponding JAR file must be available to Solr, perhaps through a `` directive in `solrconfig.xml`. +The corresponding JAR file must be available to Solr, perhaps through a `` directive. `enabled`:: + diff --git a/solr/solr-ref-guide/modules/configuration-guide/pages/configuring-solrconfig-xml.adoc b/solr/solr-ref-guide/modules/configuration-guide/pages/configuring-solrconfig-xml.adoc index 3680b928896..324a1fdd09e 100644 --- a/solr/solr-ref-guide/modules/configuration-guide/pages/configuring-solrconfig-xml.adoc +++ b/solr/solr-ref-guide/modules/configuration-guide/pages/configuring-solrconfig-xml.adoc @@ -49,7 +49,6 @@ The `solrconfig.xml` file is located in the `conf/` directory for each collectio Several well-commented example files can be found in the `server/solr/configsets/` directories demonstrating best practices for many different types of installations. Some `solrconfig.xml` aspects are documented in other sections. -See xref:libs.adoc#lib-directives-in-solrconfig[lib directives in SolrConfig], which can be used for both Plugins and Resources. **** // This tags the below list so it can be used in the parent page section list diff --git a/solr/solr-ref-guide/modules/configuration-guide/pages/libs.adoc b/solr/solr-ref-guide/modules/configuration-guide/pages/libs.adoc index 269e56f4169..2ad86d6355b 100644 --- a/solr/solr-ref-guide/modules/configuration-guide/pages/libs.adoc +++ b/solr/solr-ref-guide/modules/configuration-guide/pages/libs.adoc @@ -47,32 +47,3 @@ Certain plugins or add-ons to plugins require placement here, and they will have Solr incorporates Jetty for providing HTTP server functionality. Jetty has some directories that contain `.jar` files for itself and its own plugins / modules or JVM level plugins (e.g., loggers). Solr plugins won't work in these locations. - -== Lib Directives in SolrConfig - -_Both_ plugin and xref:resource-loading.adoc[resource] file paths are configurable via `` directives in `solrconfig.xml`. -When a directive matches a directory, then resources can be resolved from it. -When a directive matches a `.jar` file, Solr plugins and their dependencies are resolved from it. -Resources can be placed in a `.jar` too but that's unusual. -It's erroneous to refer to any other type of file. - -A `` directive must have one (not both) of these two attributes: - -* `path`: used to refer to a single directory (for resources) or file (for a plugin `.jar`) - -* `dir`: used to refer to _all_ direct descendants of the specified directory. Optionally supply a `regex` attribute to filter these to those matching the regular expression. - -All directories are resolved as relative to the Solr core's `instanceDir`. - -These examples show how to load modules into Solr: - -[source,xml] ----- - - - - - - - ----- diff --git a/solr/solr-ref-guide/modules/configuration-guide/pages/resource-loading.adoc b/solr/solr-ref-guide/modules/configuration-guide/pages/resource-loading.adoc index bcdbe17c5ef..3825f362de0 100644 --- a/solr/solr-ref-guide/modules/configuration-guide/pages/resource-loading.adoc +++ b/solr/solr-ref-guide/modules/configuration-guide/pages/resource-loading.adoc @@ -37,10 +37,5 @@ Prefer to put resources here. == Resources in Other Places -Resources can also be placed in an arbitrary directory and xref:libs.adoc#lib-directives-in-solrconfig[referenced] from a `` directive in `solrconfig.xml`, provided the directive refers to a directory and not the actual resource file. -Example: `` -This choice may make sense if the resource is too large for a configset in ZooKeeper. -However it's up to you to somehow ensure that all nodes in your cluster have access to these resources. - Finally, and this is very unusual, resources can also be packaged inside `.jar` files from which they will be referenced. That might make sense for default resources wherein a plugin user can override it via placing the same-named file in a configSet. diff --git a/solr/solr-ref-guide/modules/configuration-guide/pages/solr-modules.adoc b/solr/solr-ref-guide/modules/configuration-guide/pages/solr-modules.adoc index 93a5f0b4ff6..99740b32db1 100644 --- a/solr/solr-ref-guide/modules/configuration-guide/pages/solr-modules.adoc +++ b/solr/solr-ref-guide/modules/configuration-guide/pages/solr-modules.adoc @@ -45,10 +45,5 @@ You can also specify the modules to include when using the Solr CLI to start Sol bin/solr start -e techproducts -Dsolr.modules=scripting ---- -NOTE: If you only wish to enable a module for certain collections, you may add `` tags to `solrconfig.xml` in applicable configset(s). -as explained in xref:configuration-guide:libs.adoc[Lib Directories]. -Collection-level plugins will work if the module is enabled either per collection (``) or for the whole Solr node. -Node-level plugins such as those specified in `solr.xml` will not work when using the `` option in `solrconfig.xml` because configsets configure collections, not the node. They must be enabled for the entire Solr node, as described above. - Some modules may have been made available as packages for the xref:configuration-guide:package-manager.adoc[Package Manager], check by listing available packages. diff --git a/solr/solr-ref-guide/modules/configuration-guide/pages/update-request-processors.adoc b/solr/solr-ref-guide/modules/configuration-guide/pages/update-request-processors.adoc index 8ac9faf031f..3abebae9747 100644 --- a/solr/solr-ref-guide/modules/configuration-guide/pages/update-request-processors.adoc +++ b/solr/solr-ref-guide/modules/configuration-guide/pages/update-request-processors.adoc @@ -424,7 +424,7 @@ The {solr-javadocs}/modules/langid/index.html[`langid`] module provides:: The {solr-javadocs}/modules/analysis-extras/index.html[`analysis-extras`] module provides:: {solr-javadocs}/modules/analysis-extras/org/apache/solr/update/processor/OpenNLPExtractNamedEntitiesUpdateProcessorFactory.html[OpenNLPExtractNamedEntitiesUpdateProcessorFactory]::: Update document(s) to be indexed with named entities extracted using an OpenNLP NER model. -Note that in order to use model files larger than 1MB on SolrCloud, you must either xref:deployment-guide:zookeeper-ensemble#increasing-the-file-size-limit[configure both ZooKeeper server and clients] or xref:libs.adoc#lib-directives-in-solrconfig[store the model files on the filesystem] on each node hosting a collection replica. +Note that in order to use model files larger than 1MB on SolrCloud, you must xref:deployment-guide:zookeeper-ensemble#increasing-the-file-size-limit[configure both ZooKeeper server and clients]. === Update Processor Factories You Should _Not_ Modify or Remove diff --git a/solr/solr-ref-guide/modules/deployment-guide/pages/rule-based-authorization-plugin.adoc b/solr/solr-ref-guide/modules/deployment-guide/pages/rule-based-authorization-plugin.adoc index 2d4c528c20e..7e99462bc96 100644 --- a/solr/solr-ref-guide/modules/deployment-guide/pages/rule-based-authorization-plugin.adoc +++ b/solr/solr-ref-guide/modules/deployment-guide/pages/rule-based-authorization-plugin.adoc @@ -401,7 +401,6 @@ If edit permissions should only be applied to specific collections, a custom per Note that this allows schema read permissions for _all_ collections. If read permissions should only be applied to specific collections, a custom permission would need to be created. * *config-edit*: this permission is allowed to edit a collection's configuration using the xref:configuration-guide:config-api.adoc[], the xref:configuration-guide:request-parameters-api.adoc[], and other APIs which modify `configoverlay.json`. -Because configs xref:configuration-guide:libs.adoc#lib-directives-in-solrconfig[can add libraries/custom code] from various locations, loading any new code via a trusted SolrConfig is explicitly allowed for users with this permission. Note that this allows configuration edit permissions for _all_ collections. If edit permissions should only be applied to specific collections, a custom permission would need to be created. * *config-read*: this permission is allowed to read a collection's configuration using the xref:configuration-guide:config-api.adoc[], the xref:configuration-guide:request-parameters-api.adoc[], xref:configuration-guide:configsets-api.adoc#configsets-list[Configsets API], the Admin UI's xref:configuration-guide:configuration-files.adoc#files-screen[Files Screen], and other APIs accessing configuration. diff --git a/solr/solr-ref-guide/modules/indexing-guide/pages/indexing-with-tika.adoc b/solr/solr-ref-guide/modules/indexing-guide/pages/indexing-with-tika.adoc index b1344ed5519..b0cdb7eba30 100644 --- a/solr/solr-ref-guide/modules/indexing-guide/pages/indexing-with-tika.adoc +++ b/solr/solr-ref-guide/modules/indexing-guide/pages/indexing-with-tika.adoc @@ -421,13 +421,8 @@ Also see the section <> for an example. If you have started Solr with one of the supplied xref:configuration-guide:config-sets.adoc[example configsets], you may already have the `ExtractingRequestHandler` configured by default. -First, you must enable the xref:#module[Module]. -If `solrconfig.xml` is not already configured, you will need to modify it to find the `ExtractingRequestHandler` and its dependencies: - -[source,xml] ----- - ----- +First, the `extraction` xref:#module[module] must be enabled. +This can be done by specifying the environment variable `SOLR_MODULES=extraction` in your startup configuration. You can then configure the `ExtractingRequestHandler` in `solrconfig.xml`. The following is the default configuration found in Solr's `sample_techproducts_configs` configset, which you can modify as needed: diff --git a/solr/solr-ref-guide/modules/query-guide/pages/learning-to-rank.adoc b/solr/solr-ref-guide/modules/query-guide/pages/learning-to-rank.adoc index 1d3f575ba03..fcdf78e6315 100644 --- a/solr/solr-ref-guide/modules/query-guide/pages/learning-to-rank.adoc +++ b/solr/solr-ref-guide/modules/query-guide/pages/learning-to-rank.adoc @@ -111,10 +111,6 @@ In the form of JSON files your trained model or models (e.g., different models f |(custom) |(custom class extending {solr-javadocs}/modules/ltr/org/apache/solr/ltr/model/LTRScoringModel.html[LTRScoringModel]) |(not applicable) |=== -== Module - -This is provided via the `ltr` xref:configuration-guide:solr-modules.adoc[Solr Module] that needs to be enabled before use. - == Installation of LTR The ltr module requires the `modules/ltr/lib/solr-ltr-*.jar` JARs. @@ -125,13 +121,8 @@ Learning-To-Rank is a module and therefore its plugins must be configured in `so === Minimum Requirements -* Include the required module JARs. -Note that by default paths are relative to the Solr core, so they may need adjustments to your configuration, or an explicit specification of the `$solr.install.dir`. -+ -[source,xml] ----- - ----- +* Enable the `ltr` module to make the LTR classes available on Solr's classpath. +See xref:configuration-guide:solr-modules.adoc[Solr Module] for more details. * Declaration of the `ltr` query parser. + @@ -248,11 +239,11 @@ Assuming that you consider to use a large model placed at `/path/to/models/myMod } ---- -First, add the directory to Solr's resource paths with a xref:configuration-guide:libs.adoc#lib-directives-in-solrconfig[`` directive]: +First, add the directory to Solr's resource paths with a xref:configuration-guide:configuring-solr-xml.adoc#the-solr-element[solr.xml `` directive]: [source,xml] ---- - + /path/to/models" ---- Then, configure `DefaultWrapperModel` to wrap `myModel.json`: @@ -273,8 +264,6 @@ Then, configure `DefaultWrapperModel` to wrap `myModel.json`: NOTE: No `"features"` are configured in `myWrapperModel` because the features of the wrapped model (`myModel`) will be used; also note that the `"store"` configured for the wrapper model must match that of the wrapped model i.e., in this example the feature store called `largeModelsFeatureStore` is used. -CAUTION: `` doesn't work as expected in this case, because `SolrResourceLoader` considers given resources as JAR if `` indicates files. - As an alternative to the above-described `DefaultWrapperModel`, it is possible to xref:deployment-guide:zookeeper-ensemble.adoc#increasing-the-file-size-limit[increase ZooKeeper's file size limit]. === Applying Changes diff --git a/solr/solr-ref-guide/modules/upgrade-notes/pages/major-changes-in-solr-10.adoc b/solr/solr-ref-guide/modules/upgrade-notes/pages/major-changes-in-solr-10.adoc index 2d1902a02fa..af919ebe9d3 100644 --- a/solr/solr-ref-guide/modules/upgrade-notes/pages/major-changes-in-solr-10.adoc +++ b/solr/solr-ref-guide/modules/upgrade-notes/pages/major-changes-in-solr-10.adoc @@ -93,3 +93,7 @@ Please note this also removes the ability to share resource intensive objects ac The removed writer types (invoked as part of the `wt` parameter) include `python`, `ruby`, `php`, and `phps`. * The deprecated support for configuring replication using master/slave terminology is removed. Use leader/follower. + +* Support for the `` directive, which historically could be used in solrconfig.xml to add JARs on a core-by-core basis, was deprecated in 9.8 and has now been removed. +Users that need to vary JAR accessibility on a per-core basis can use Solr's xref:configuration-guide:package-manager.adoc[Package Manager]. +Users who that don't need to vary JAR access on a per-core basis have several options, including the xref:configuration-guide:configuring-solr-xml.adoc[`` tag supported by solr.xml] or manipulation of Solr's classpath prior to JVM startup. diff --git a/solr/solr-ref-guide/modules/upgrade-notes/pages/major-changes-in-solr-9.adoc b/solr/solr-ref-guide/modules/upgrade-notes/pages/major-changes-in-solr-9.adoc index 399ceba5926..fc3a9d27577 100644 --- a/solr/solr-ref-guide/modules/upgrade-notes/pages/major-changes-in-solr-9.adoc +++ b/solr/solr-ref-guide/modules/upgrade-notes/pages/major-changes-in-solr-9.adoc @@ -380,7 +380,7 @@ Other relevant placement strategies should be used instead, such as autoscaling ** The `solrj-deps` (SolrJ Dependencies) are no longer separated out from the other Server jars. ** Please refer to the SolrJ Maven artifact to see the exact dependencies you need to include from `server/solr-webapp/webapp/WEB-INF/lib/` and `server/lib/ext/` if you are loading in SolrJ manually. If you plan on using SolrJ as a JDBC driver, please refer to the xref:query-guide:sql-query.adoc#generic-clients[JDBC documentation] -** More information can be found in the xref:configuration-guide:libs.adoc#lib-directives-in-solrconfig[Libs documentation]. +** More information can be found in the xref:configuration-guide:libs.adoc[Libs documentation]. * SolrJ class `CloudSolrClient` now supports HTTP2. It has a new Builder. See `CloudLegacySolrClient` for the 8.x version of this class. * In Backup request responses, the `response` key now uses a map to return information instead of a list. This is only applicable for users returning information in JSON format, which is the default behavior. From 4510baf059f6e5e22b677f3982fa25fa81d074aa Mon Sep 17 00:00:00 2001 From: Jason Gerlowski Date: Wed, 4 Dec 2024 12:27:59 -0500 Subject: [PATCH 32/33] Remove errant 'wt'-checking for file-fetching --- .../java/org/apache/solr/handler/ReplicationHandler.java | 9 --------- 1 file changed, 9 deletions(-) diff --git a/solr/core/src/java/org/apache/solr/handler/ReplicationHandler.java b/solr/core/src/java/org/apache/solr/handler/ReplicationHandler.java index 2424addaff8..d059ad38d53 100644 --- a/solr/core/src/java/org/apache/solr/handler/ReplicationHandler.java +++ b/solr/core/src/java/org/apache/solr/handler/ReplicationHandler.java @@ -76,7 +76,6 @@ import org.apache.solr.client.api.model.SolrJerseyResponse; import org.apache.solr.common.SolrException; import org.apache.solr.common.SolrException.ErrorCode; -import org.apache.solr.common.params.CommonParams; import org.apache.solr.common.params.CoreAdminParams; import org.apache.solr.common.params.ModifiableSolrParams; import org.apache.solr.common.params.SolrParams; @@ -347,14 +346,6 @@ private void getFileStream(SolrParams solrParams, SolrQueryResponse rsp, SolrQue return; } - if (solrParams.getParams(CommonParams.WT) == null) { - reportErrorOnResponse( - rsp, - "Missing wt parameter", - new SolrException(SolrException.ErrorCode.BAD_REQUEST, "wt not specified in request")); - return; - } - coreReplicationAPI.fetchFile( fileName, dirType, From 7547395eaff44fe4f0bc084609fef91b83a7026c Mon Sep 17 00:00:00 2001 From: Christos Malliaridis Date: Fri, 6 Dec 2024 23:35:17 +0200 Subject: [PATCH 33/33] Fix missing change in RunExampleTool from PR (#2897) --- solr/core/src/java/org/apache/solr/cli/RunExampleTool.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/solr/core/src/java/org/apache/solr/cli/RunExampleTool.java b/solr/core/src/java/org/apache/solr/cli/RunExampleTool.java index 50c0162881a..6d7b349911c 100644 --- a/solr/core/src/java/org/apache/solr/cli/RunExampleTool.java +++ b/solr/core/src/java/org/apache/solr/cli/RunExampleTool.java @@ -655,7 +655,7 @@ protected Map startSolr( String startCmd = String.format( Locale.ROOT, - "\"%s\" start %s -p %d --solr-home \"%s\" %s %s %s %s %s %s %s", + "\"%s\" start %s -p %d --solr-home \"%s\" %s %s %s %s %s %s %s %s", callScript, cloudModeArg, port,