Merge branch 'master' into feature/searchable-snapshots

Author: DaveCTurner

build.gradle

@@ -106,6 +106,7 @@ subprojects {
     // is greater than the number of unformatted projects, this can be
     // switched to an exclude list, and eventualy removed completely.
     def projectPathsToFormat = [
+      ':build-tools',
       ':x-pack:plugin:enrich'
     ]
 
@@ -114,6 +115,10 @@ subprojects {
 
       spotless {
         java {
+          // Normally this isn't necessary, but we have Java sources in
+          // non-standard places
+          target '**/*.java'
+
           removeUnusedImports()
           eclipse().configFile rootProject.file('.eclipseformat.xml')
           trimTrailingWhitespace()

buildSrc/reaper/src/main/java/org/elasticsearch/gradle/reaper/Reaper.java

@@ -65,14 +65,14 @@ public static void main(String[] args) throws Exception {
         }
         Path inputDir = Paths.get(args[0]);
 
-        try (Reaper reaper = new Reaper(inputDir)){
+        try (Reaper reaper = new Reaper(inputDir)) {
             System.in.read();
             reaper.reap();
         }
     }
 
     private void reap() {
-        try (Stream<Path> stream = Files.list(inputDir)){
+        try (Stream<Path> stream = Files.list(inputDir)) {
             final List<Path> inputFiles = stream.filter(p -> p.getFileName().toString().endsWith(".cmd")).collect(Collectors.toList());
 
             for (Path inputFile : inputFiles) {
@@ -118,7 +118,7 @@ private void delete(Path toDelete) {
     @Override
     public void close() {
         if (failed == false) {
-            try (Stream<Path> stream = Files.walk(inputDir)){
+            try (Stream<Path> stream = Files.walk(inputDir)) {
                 stream.sorted(Comparator.reverseOrder()).forEach(this::delete);
             } catch (IOException e) {
                 throw new UncheckedIOException(e);

buildSrc/src/main/java/org/elasticsearch/gradle/BwcVersions.java

@@ -109,15 +109,20 @@ public BwcVersions(List<String> versionLines) {
     }
 
     protected BwcVersions(List<String> versionLines, Version currentVersionProperty) {
-        this(versionLines.stream()
-            .map(LINE_PATTERN::matcher)
-            .filter(Matcher::matches)
-            .map(match -> new Version(
-                Integer.parseInt(match.group(1)),
-                Integer.parseInt(match.group(2)),
-                Integer.parseInt(match.group(3))
-            ))
-            .collect(Collectors.toCollection(TreeSet::new)), currentVersionProperty);
+        this(
+            versionLines.stream()
+                .map(LINE_PATTERN::matcher)
+                .filter(Matcher::matches)
+                .map(
+                    match -> new Version(
+                        Integer.parseInt(match.group(1)),
+                        Integer.parseInt(match.group(2)),
+                        Integer.parseInt(match.group(3))
+                    )
+                )
+                .collect(Collectors.toCollection(TreeSet::new)),
+            currentVersionProperty
+        );
     }
 
     // for testkit tests, until BwcVersions is extracted into an extension
@@ -140,27 +145,29 @@ public BwcVersions(SortedSet<Version> allVersions, Version currentVersionPropert
 
         Map<Version, UnreleasedVersionInfo> unreleased = new HashMap<>();
         for (Version unreleasedVersion : getUnreleased()) {
-            unreleased.put(unreleasedVersion,
-                new UnreleasedVersionInfo(unreleasedVersion, getBranchFor(unreleasedVersion), getGradleProjectPathFor(unreleasedVersion)));
+            unreleased.put(
+                unreleasedVersion,
+                new UnreleasedVersionInfo(unreleasedVersion, getBranchFor(unreleasedVersion), getGradleProjectPathFor(unreleasedVersion))
+            );
         }
         this.unreleased = Collections.unmodifiableMap(unreleased);
     }
 
     private void assertNoOlderThanTwoMajors() {
         Set<Integer> majors = groupByMajor.keySet();
         if (majors.size() != 2 && currentVersion.getMinor() != 0 && currentVersion.getRevision() != 0) {
-            throw new IllegalStateException(
-                "Expected exactly 2 majors in parsed versions but found: " + majors
-            );
+            throw new IllegalStateException("Expected exactly 2 majors in parsed versions but found: " + majors);
         }
     }
 
     private void assertCurrentVersionMatchesParsed(Version currentVersionProperty) {
         if (currentVersionProperty.equals(currentVersion) == false) {
             throw new IllegalStateException(
-                "Parsed versions latest version does not match the one configured in build properties. " +
-                    "Parsed latest version is " + currentVersion + " but the build has " +
-                    currentVersionProperty
+                "Parsed versions latest version does not match the one configured in build properties. "
+                    + "Parsed latest version is "
+                    + currentVersion
+                    + " but the build has "
+                    + currentVersionProperty
             );
         }
     }
@@ -175,12 +182,7 @@ public UnreleasedVersionInfo unreleasedInfo(Version version) {
     public void forPreviousUnreleased(Consumer<UnreleasedVersionInfo> consumer) {
         List<UnreleasedVersionInfo> collect = getUnreleased().stream()
             .filter(version -> version.equals(currentVersion) == false)
-            .map(version -> new UnreleasedVersionInfo(
-                    version,
-                    getBranchFor(version),
-                    getGradleProjectPathFor(version)
-                )
-            )
+            .map(version -> new UnreleasedVersionInfo(version, getBranchFor(version), getGradleProjectPathFor(version)))
             .collect(Collectors.toList());
 
         collect.forEach(uvi -> consumer.accept(uvi));
@@ -196,22 +198,18 @@ private String getGradleProjectPathFor(Version version) {
         Map<Integer, List<Version>> releasedMajorGroupedByMinor = getReleasedMajorGroupedByMinor();
 
         if (version.getRevision() == 0) {
-            List<Version> unreleasedStagedOrMinor = getUnreleased().stream()
-                .filter(v -> v.getRevision() == 0)
-                .collect(Collectors.toList());
+            List<Version> unreleasedStagedOrMinor = getUnreleased().stream().filter(v -> v.getRevision() == 0).collect(Collectors.toList());
             if (unreleasedStagedOrMinor.size() > 2) {
                 if (unreleasedStagedOrMinor.get(unreleasedStagedOrMinor.size() - 2).equals(version)) {
                     return ":distribution:bwc:minor";
-                } else{
+                } else {
                     return ":distribution:bwc:staged";
                 }
             } else {
                 return ":distribution:bwc:minor";
             }
         } else {
-            if (releasedMajorGroupedByMinor
-                .getOrDefault(version.getMinor(), emptyList())
-                .contains(version)) {
+            if (releasedMajorGroupedByMinor.getOrDefault(version.getMinor(), emptyList()).contains(version)) {
                 return ":distribution:bwc:bugfix";
             } else {
                 return ":distribution:bwc:maintenance";
@@ -229,7 +227,7 @@ private String getBranchFor(Version version) {
                 return "master";
             case ":distribution:bwc:minor":
                 // The .x branch will always point to the latest minor (for that major), so a "minor" project will be on the .x branch
-                //  unless there is more recent (higher) minor.
+                // unless there is more recent (higher) minor.
                 final Version latestInMajor = getLatestVersionByKey(groupByMajor, version.getMajor());
                 if (latestInMajor.getMinor() == version.getMinor()) {
                     return version.getMajor() + ".x";
@@ -279,23 +277,16 @@ public List<Version> getUnreleased() {
             }
         }
 
-        return unmodifiableList(
-            unreleased.stream()
-                .sorted()
-                .distinct()
-                .collect(Collectors.toList())
-        );
+        return unmodifiableList(unreleased.stream().sorted().distinct().collect(Collectors.toList()));
     }
 
     private Version getLatestInMinor(int major, int minor) {
-        return groupByMajor.get(major).stream()
-            .filter(v -> v.getMinor() == minor)
-            .max(Version::compareTo)
-            .orElse(null);
+        return groupByMajor.get(major).stream().filter(v -> v.getMinor() == minor).max(Version::compareTo).orElse(null);
     }
 
     private Version getLatestVersionByKey(Map<Integer, List<Version>> groupByMajor, int key) {
-        return groupByMajor.getOrDefault(key, emptyList()).stream()
+        return groupByMajor.getOrDefault(key, emptyList())
+            .stream()
             .max(Version::compareTo)
             .orElseThrow(() -> new IllegalStateException("Unexpected number of versions in collection"));
     }
@@ -307,11 +298,9 @@ private Map<Integer, List<Version>> getReleasedMajorGroupedByMinor() {
         final Map<Integer, List<Version>> groupByMinor;
         if (currentMajorVersions.size() == 1) {
             // Current is an unreleased major: x.0.0 so we have to look for other unreleased versions in the previous major
-            groupByMinor = previousMajorVersions.stream()
-                .collect(Collectors.groupingBy(Version::getMinor, Collectors.toList()));
+            groupByMinor = previousMajorVersions.stream().collect(Collectors.groupingBy(Version::getMinor, Collectors.toList()));
         } else {
-            groupByMinor = currentMajorVersions.stream()
-                .collect(Collectors.groupingBy(Version::getMinor, Collectors.toList()));
+            groupByMinor = currentMajorVersions.stream().collect(Collectors.groupingBy(Version::getMinor, Collectors.toList()));
         }
         return groupByMinor;
     }
@@ -321,37 +310,37 @@ public void compareToAuthoritative(List<Version> authoritativeReleasedVersions)
         notReallyReleased.removeAll(authoritativeReleasedVersions);
         if (notReallyReleased.isEmpty() == false) {
             throw new IllegalStateException(
-                "out-of-date released versions" +
-                    "\nFollowing versions are not really released, but the build thinks they are: " + notReallyReleased
+                "out-of-date released versions"
+                    + "\nFollowing versions are not really released, but the build thinks they are: "
+                    + notReallyReleased
             );
         }
 
         Set<Version> incorrectlyConsideredUnreleased = new HashSet<>(authoritativeReleasedVersions);
         incorrectlyConsideredUnreleased.retainAll(getUnreleased());
         if (incorrectlyConsideredUnreleased.isEmpty() == false) {
             throw new IllegalStateException(
-                "out-of-date released versions" +
-                    "\nBuild considers versions unreleased, " +
-                    "but they are released according to an authoritative source: " + incorrectlyConsideredUnreleased +
-                    "\nThe next versions probably needs to be added to Version.java (CURRENT doesn't count)."
+                "out-of-date released versions"
+                    + "\nBuild considers versions unreleased, "
+                    + "but they are released according to an authoritative source: "
+                    + incorrectlyConsideredUnreleased
+                    + "\nThe next versions probably needs to be added to Version.java (CURRENT doesn't count)."
             );
         }
     }
 
     private List<Version> getReleased() {
         List<Version> unreleased = getUnreleased();
-        return groupByMajor.values().stream()
+        return groupByMajor.values()
+            .stream()
             .flatMap(Collection::stream)
             .filter(each -> unreleased.contains(each) == false)
             .collect(Collectors.toList());
     }
 
     public List<Version> getIndexCompatible() {
         return unmodifiableList(
-            Stream.concat(
-                groupByMajor.get(currentVersion.getMajor() - 1).stream(),
-                groupByMajor.get(currentVersion.getMajor()).stream()
-            )
+            Stream.concat(groupByMajor.get(currentVersion.getMajor() - 1).stream(), groupByMajor.get(currentVersion.getMajor()).stream())
                 .collect(Collectors.toList())
         );
     }
@@ -361,10 +350,7 @@ public List<Version> getWireCompatible() {
 
         List<Version> prevMajors = groupByMajor.get(currentVersion.getMajor() - 1);
         int minor = prevMajors.get(prevMajors.size() - 1).getMinor();
-        for (int i = prevMajors.size() - 1;
-             i > 0 && prevMajors.get(i).getMinor() == minor;
-             i--
-        ) {
+        for (int i = prevMajors.size() - 1; i > 0 && prevMajors.get(i).getMinor() == minor; i--) {
             wireCompat.add(prevMajors.get(i));
         }
         wireCompat.addAll(groupByMajor.get(currentVersion.getMajor()));

buildSrc/src/main/java/org/elasticsearch/gradle/ConcatFilesTask.java

@@ -55,15 +55,19 @@ public void setFiles(FileTree files) {
     }
 
     @InputFiles
-    public FileTree getFiles() { return files; }
+    public FileTree getFiles() {
+        return files;
+    }
 
     public void setHeaderLine(String headerLine) {
         this.headerLine = headerLine;
     }
 
     @Input
     @Optional
-    public String getHeaderLine() { return headerLine; }
+    public String getHeaderLine() {
+        return headerLine;
+    }
 
     public void setTarget(File target) {
         this.target = target;
@@ -77,20 +81,15 @@ public File getTarget() {
     @TaskAction
     public void concatFiles() throws IOException {
         if (getHeaderLine() != null) {
-            Files.write(
-                getTarget().toPath(),
-                (getHeaderLine() + '\n').getBytes(StandardCharsets.UTF_8)
-            );
+            Files.write(getTarget().toPath(), (getHeaderLine() + '\n').getBytes(StandardCharsets.UTF_8));
         }
 
         // To remove duplicate lines
         LinkedHashSet<String> uniqueLines = new LinkedHashSet<>();
         for (File f : getFiles()) {
             uniqueLines.addAll(Files.readAllLines(f.toPath(), StandardCharsets.UTF_8));
         }
-        Files.write(
-            getTarget().toPath(), uniqueLines, StandardCharsets.UTF_8, StandardOpenOption.APPEND
-        );
+        Files.write(getTarget().toPath(), uniqueLines, StandardCharsets.UTF_8, StandardOpenOption.APPEND);
     }
 
 }

buildSrc/src/main/java/org/elasticsearch/gradle/DistributionDownloadPlugin.java

@@ -105,8 +105,10 @@ void setupDistributions(Project project) {
             if (distribution.getType().shouldExtract()) {
                 // for the distribution extracted, add a root level task that does the extraction, and depend on that
                 // extracted configuration as an artifact consisting of the extracted distribution directory
-                dependencies.add(distribution.getExtracted().configuration.getName(),
-                    projectDependency(project, ":", configName("extracted_elasticsearch", distribution)));
+                dependencies.add(
+                    distribution.getExtracted().configuration.getName(),
+                    projectDependency(project, ":", configName("extracted_elasticsearch", distribution))
+                );
                 // ensure a root level download task exists
                 setupRootDownload(project.getRootProject(), distribution);
             }
@@ -139,7 +141,7 @@ private void setupRootDownload(Project rootProject, ElasticsearchDistribution di
             TaskProvider<Sync> extractTask = rootProject.getTasks().register(extractTaskName, Sync.class, syncTask -> {
                 syncTask.dependsOn(downloadConfig);
                 syncTask.into(extractDir);
-                syncTask.from((Callable<FileTree>)() -> {
+                syncTask.from((Callable<FileTree>) () -> {
                     File archiveFile = archiveGetter.get();
                     String archivePath = archiveFile.toString();
                     if (archivePath.endsWith(".zip")) {
@@ -150,9 +152,12 @@ private void setupRootDownload(Project rootProject, ElasticsearchDistribution di
                     throw new IllegalStateException("unexpected file extension on [" + archivePath + "]");
                 });
             });
-            rootProject.getArtifacts().add(extractedConfigName,
-                rootProject.getLayout().getProjectDirectory().dir(extractDir),
-                artifact -> artifact.builtBy(extractTask));
+            rootProject.getArtifacts()
+                .add(
+                    extractedConfigName,
+                    rootProject.getLayout().getProjectDirectory().dir(extractDir),
+                    artifact -> artifact.builtBy(extractTask)
+                );
         }
     }
 
@@ -219,7 +224,6 @@ private Object dependencyNotation(Project project, ElasticsearchDistribution dis
             return "org.elasticsearch.distribution.integ-test-zip:elasticsearch:" + distribution.getVersion() + "@zip";
         }
 
-
         Version distroVersion = Version.fromString(distribution.getVersion());
         String extension = distribution.getType().toString();
         String classifier = ":x86_64";
@@ -293,9 +297,16 @@ private static String distributionProjectName(ElasticsearchDistribution distribu
     }
 
     private static String configName(String prefix, ElasticsearchDistribution distribution) {
-        return prefix + "_" + distribution.getVersion() + "_" + distribution.getType() + "_" +
-            (distribution.getPlatform() == null ? "" : distribution.getPlatform() + "_")
-            + distribution.getFlavor() + (distribution.getBundledJdk() ? "" : "_nojdk");
+        return String.format(
+            Locale.ROOT,
+            "%s_%s_%s_%s%s%s",
+            prefix,
+            distribution.getVersion(),
+            distribution.getType(),
+            distribution.getPlatform() == null ? "" : distribution.getPlatform() + "_",
+            distribution.getFlavor(),
+            distribution.getBundledJdk() ? "" : "_nojdk"
+        );
     }
 
     private static String capitalize(String s) {