SOLR-17406: Introduce Version Catalogs

buildSrc/build.gradle → build-tools/build-infra/build.gradle

@@ -15,24 +15,44 @@
  * limitations under the License.
  */
 
+plugins {
+ id "java-gradle-plugin"
+ alias(libs.plugins.diffplug.spotless) apply false
+}
+
 repositories {
  mavenCentral()
 }
 
-ext {
- // Minimum Java version required to compile buildSrc.
- minJavaVersion = JavaVersion.VERSION_11
-}
+group = "org.apache"
 
 // Make sure the build environment is consistent.
-apply from: file('../gradle/validation/check-environment.gradle')
+apply from: file('../../gradle/conventions.gradle')
+apply from: file('../../gradle/validation/check-environment.gradle')
+
+// Add spotless/ tidy.
+tasks.register("checkJdkInternalsExportedToGradle") {}
+apply from: file('../../gradle/validation/spotless.gradle')
 
-// Load common buildSrc and script deps.
-apply from: file("scriptDepVersions.gradle")
+java {
+ sourceCompatibility = JavaVersion.toVersion(libs.versions.minJava.get())
+ targetCompatibility = JavaVersion.toVersion(libs.versions.minJava.get())
+}
+
+gradlePlugin {
+ automatedPublishing = false
+
+ plugins {
+ buildInfra {
+ id = 'solr.build-infra'
+ implementationClass = 'org.apache.lucene.gradle.buildinfra.BuildInfraPlugin'
+ }
+ }
+}
 
 dependencies {
  implementation gradleApi()
  implementation localGroovy()
 
- implementation "commons-codec:commons-codec:${scriptDepVersions['commons-codec']}"
+ implementation libs.commonscodec.commonscodec
 }

dev-tools/solr-missing-doclet/settings.gradle → build-tools/build-infra/settings.gradle

@@ -15,4 +15,13 @@
  * limitations under the License.
  */
 
-rootProject.name = "missing-doclet"
+rootProject.name = 'build-infra'
+
+// Use project's version catalog for centralized dependency management
+dependencyResolutionManagement {
+ versionCatalogs {
+ libs {
+ from(files("../../gradle/libs.versions.toml"))
+ }
+ }
+}

buildSrc/src/main/java/org/apache/lucene/gradle/Checksum.java → build-tools/build-infra/src/main/java/org/apache/lucene/gradle/Checksum.java

@@ -27,6 +27,11 @@
 
 package org.apache.lucene.gradle;
 
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.Locale;
 import org.apache.commons.codec.digest.DigestUtils;
 import org.gradle.api.DefaultTask;
 import org.gradle.api.GradleException;
@@ -39,16 +44,10 @@
 import org.gradle.work.Incremental;
 import org.gradle.work.InputChanges;
 
-import java.io.File;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.util.Locale;
-
 public class Checksum extends DefaultTask {
  private FileCollection files;
  private File outputDir;
- private Algorithm algorithm;
+ private Algorithm algorithm = Checksum.Algorithm.SHA512;
 
  public enum Algorithm {
  MD5(new DigestUtils(DigestUtils.getMd5Digest())),

build-tools/build-infra/src/main/java/org/apache/lucene/gradle/ErrorReportingTestListener.java

@@ -0,0 +1,288 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.lucene.gradle;
+
+import java.io.BufferedReader;
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.regex.Pattern;
+import org.gradle.api.internal.tasks.testing.logging.FullExceptionFormatter;
+import org.gradle.api.internal.tasks.testing.logging.TestExceptionFormatter;
+import org.gradle.api.logging.Logger;
+import org.gradle.api.logging.Logging;
+import org.gradle.api.tasks.testing.TestDescriptor;
+import org.gradle.api.tasks.testing.TestListener;
+import org.gradle.api.tasks.testing.TestOutputEvent;
+import org.gradle.api.tasks.testing.TestOutputListener;
+import org.gradle.api.tasks.testing.TestResult;
+import org.gradle.api.tasks.testing.logging.TestLogging;
+
+/**
+ * An error reporting listener that queues test output streams and displays them on failure.
+ *
+ * <p>Heavily inspired by Elasticsearch's ErrorReportingTestListener (ASL 2.0 licensed).
+ */
+public class ErrorReportingTestListener implements TestOutputListener, TestListener {
+ private static final Logger LOGGER = Logging.getLogger(ErrorReportingTestListener.class);
+
+ private final TestExceptionFormatter formatter;
+ private final Map<TestKey, OutputHandler> outputHandlers = new ConcurrentHashMap<>();
+ private final Path spillDir;
+ private final Path outputsDir;
+ private final boolean verboseMode;
+
+ public ErrorReportingTestListener(
+ TestLogging testLogging, Path spillDir, Path outputsDir, boolean verboseMode) {
+ this.formatter = new FullExceptionFormatter(testLogging);
+ this.spillDir = spillDir;
+ this.outputsDir = outputsDir;
+ this.verboseMode = verboseMode;
+ }
+
+ @Override
+ public void onOutput(TestDescriptor testDescriptor, TestOutputEvent outputEvent) {
+ handlerFor(testDescriptor).write(outputEvent);
+ }
+
+ @Override
+ public void beforeSuite(TestDescriptor suite) {
+ // noop.
+ }
+
+ @Override
+ public void beforeTest(TestDescriptor testDescriptor) {
+ // Noop.
+ }
+
+ @Override
+ public void afterSuite(final TestDescriptor suite, TestResult result) {
+ if (suite.getParent() == null || suite.getName().startsWith("Gradle")) {
+ return;
+ }
+
+ TestKey key = TestKey.of(suite);
+ try {
+ OutputHandler outputHandler = outputHandlers.get(key);
+ if (outputHandler != null) {
+ long length = outputHandler.length();
+ if (length > 1024 * 1024 * 10) {
+ LOGGER.warn(
+ String.format(
+ Locale.ROOT,
+ "WARNING: Test %s wrote %,d bytes of output.",
+ suite.getName(),
+ length));
+ }
+ }
+
+ boolean echoOutput = Objects.equals(result.getResultType(), TestResult.ResultType.FAILURE);
+ boolean dumpOutput = echoOutput;
+
+ // If the test suite failed, report output.
+ if (dumpOutput || echoOutput) {
+ Files.createDirectories(outputsDir);
+ Path outputLog = outputsDir.resolve(getOutputLogName(suite));
+
+ // Save the output of a failing test to disk.
+ try (Writer w = Files.newBufferedWriter(outputLog, StandardCharsets.UTF_8)) {
+ if (outputHandler != null) {
+ outputHandler.copyTo(w);
+ }
+ }
+
+ if (echoOutput && !verboseMode) {
+ synchronized (this) {
+ System.out.println("");
+ System.out.println(
+ suite.getClassName()
+ + " > test suite's output saved to "
+ + outputLog
+ + ", copied below:");
+ try (BufferedReader reader =
+ Files.newBufferedReader(outputLog, StandardCharsets.UTF_8)) {
+ char[] buf = new char[1024];
+ int len;
+ while ((len = reader.read(buf)) >= 0) {
+ System.out.print(new String(buf, 0, len));
+ }
+ System.out.println();
+ }
+ }
+ }
+ }
+ } catch (IOException e) {
+ throw new UncheckedIOException(e);
+ } finally {
+ OutputHandler handler = outputHandlers.remove(key);
+ if (handler != null) {
+ try {
+ handler.close();
+ } catch (IOException e) {
+ LOGGER.error("Failed to close output handler for: " + key, e);
+ }
+ }
+ }
+ }
+
+ private static Pattern SANITIZE = Pattern.compile("[^a-zA-Z .\\-_0-9]+");
+
+ public static String getOutputLogName(TestDescriptor suite) {
+ return SANITIZE.matcher("OUTPUT-" + suite.getName() + ".txt").replaceAll("_");
+ }
+
+ @Override
+ public void afterTest(TestDescriptor testDescriptor, TestResult result) {
+ // Include test failure exception stacktrace(s) in test output log.
+ if (result.getResultType() == TestResult.ResultType.FAILURE) {
+ if (result.getExceptions().size() > 0) {
+ String message = formatter.format(testDescriptor, result.getExceptions());
+ handlerFor(testDescriptor).write(message);
+ }
+ }
+ }
+
+ private OutputHandler handlerFor(TestDescriptor descriptor) {
+ // Attach output of leaves (individual tests) to their parent.
+ if (!descriptor.isComposite()) {
+ descriptor = descriptor.getParent();
+ }
+ return outputHandlers.computeIfAbsent(TestKey.of(descriptor), (key) -> new OutputHandler());
+ }
+
+ public static class TestKey {
+ private final String key;
+
+ private TestKey(String key) {
+ this.key = key;
+ }
+
+ public static TestKey of(TestDescriptor d) {
+ StringBuilder key = new StringBuilder();
+ key.append(d.getClassName());
+ key.append("::");
+ key.append(d.getName());
+ key.append("::");
+ key.append(d.getParent() == null ? "-" : d.getParent().toString());
+ return new TestKey(key.toString());
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ return o != null && o.getClass() == this.getClass() && Objects.equals(((TestKey) o).key, key);
+ }
+
+ @Override
+ public int hashCode() {
+ return key.hashCode();
+ }
+
+ @Override
+ public String toString() {
+ return key;
+ }
+ }
+
+ private class OutputHandler implements Closeable {
+ // Max single-line buffer before automatic wrap occurs.
+ private static final int MAX_LINE_WIDTH = 1024 * 4;
+
+ private final SpillWriter buffer;
+
+ // internal stream.
+ private final PrefixedWriter sint;
+ // stdout
+ private final PrefixedWriter sout;
+ // stderr
+ private final PrefixedWriter serr;
+
+ // last used stream (so that we can flush it properly and prefixes are not screwed up).
+ private PrefixedWriter last;
+
+ public OutputHandler() {
+ buffer =
+ new SpillWriter(
+ () -> {
+ try {
+ return Files.createTempFile(spillDir, "spill-", ".tmp");
+ } catch (IOException e) {
+ throw new UncheckedIOException(e);
+ }
+ });
+
+ Writer sink = buffer;
+ if (verboseMode) {
+ sink = new StdOutTeeWriter(buffer);
+ }
+
+ sint = new PrefixedWriter(" > ", sink, MAX_LINE_WIDTH);
+ sout = new PrefixedWriter(" 1> ", sink, MAX_LINE_WIDTH);
+ serr = new PrefixedWriter(" 2> ", sink, MAX_LINE_WIDTH);
+ last = sint;
+ }
+
+ public void write(TestOutputEvent event) {
+ write(
+ (event.getDestination() == TestOutputEvent.Destination.StdOut ? sout : serr),
+ event.getMessage());
+ }
+
+ public void write(String message) {
+ write(sint, message);
+ }
+
+ public long length() throws IOException {
+ return buffer.length();
+ }
+
+ private void write(PrefixedWriter out, String message) {
+ try {
+ if (out != last) {
+ last.completeLine();
+ last = out;
+ }
+ out.write(message);
+ } catch (IOException e) {
+ throw new UncheckedIOException("Unable to write to test output.", e);
+ }
+ }
+
+ public void copyTo(Writer out) throws IOException {
+ flush();
+ buffer.copyTo(out);
+ }
+
+ public void flush() throws IOException {
+ sout.completeLine();
+ serr.completeLine();
+ buffer.flush();
+ }
+
+ @Override
+ public void close() throws IOException {
+ buffer.close();
+ }
+ }
+}

buildSrc/src/main/java/org/apache/lucene/gradle/GradlePropertiesGenerator.java → build-tools/build-infra/src/main/java/org/apache/lucene/gradle/GradlePropertiesGenerator.java

@@ -67,6 +67,6 @@ public void run(Path source, Path destination) throws IOException {
  fileContent = fileContent.replace(entry.getKey(), String.valueOf(entry.getValue()));
  }
  Files.writeString(
-  destination, fileContent, StandardCharsets.UTF_8, StandardOpenOption.CREATE_NEW);
+ destination, fileContent, StandardCharsets.UTF_8, StandardOpenOption.CREATE_NEW);
  }
 }