Merge branch 'master' into feature/ml-inference-add-description-api

Author: benwtrent

buildSrc/src/integTest/groovy/org/elasticsearch/gradle/internal/InternalDistributionArchiveSetupPluginFuncTest.groovy

@@ -0,0 +1,208 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch 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.elasticsearch.gradle.internal
+
+import org.apache.commons.compress.archivers.tar.TarArchiveEntry
+import org.apache.commons.compress.archivers.tar.TarArchiveInputStream
+import org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream
+import org.apache.tools.zip.ZipEntry
+import org.apache.tools.zip.ZipFile
+import org.elasticsearch.gradle.fixtures.AbstractGradleFuncTest
+import org.gradle.testkit.runner.BuildResult
+import org.gradle.testkit.runner.TaskOutcome
+
+class InternalDistributionArchiveSetupPluginFuncTest extends AbstractGradleFuncTest {
+
+    def setup() {
+        buildFile << """
+        import org.elasticsearch.gradle.tar.SymbolicLinkPreservingTar
+        
+        plugins {
+            id 'elasticsearch.internal-distribution-archive-setup'
+        }
+        """
+        file('someFile.txt') << "some content"
+    }
+
+    def "applies defaults to tar tasks"() {
+        given:
+        file('someFile.txt') << "some content"
+        buildFile << """
+        tasks.register('${buildTaskName}', SymbolicLinkPreservingTar) {
+            from 'someFile.txt'
+        }
+        """
+
+        when:
+        def result = gradleRunner(buildTaskName).build()
+
+        then:
+        file(expectedOutputArchivePath).exists()
+        assertTarPermissionDefaults(file(expectedOutputArchivePath))
+        assertEmptyDirTasksTriggered(result)
+
+        where:
+        buildTaskName       | expectedOutputArchivePath
+        "buildDarwinTar"    | "darwin-tar/build/distributions/elasticsearch.tar.gz"
+        "buildOssDarwinTar" | "oss-darwin-tar/build/distributions/elasticsearch-oss.tar.gz"
+    }
+
+    def "applies defaults to zip tasks"() {
+        given:
+        buildFile << """
+        tasks.register('${buildTaskName}', Zip) {
+            from 'someFile.txt'
+        }
+        """
+
+        when:
+        def result = gradleRunner(buildTaskName).build()
+
+        then:
+        file(expectedOutputArchivePath).exists()
+        assertZipPermissionDefaults(file(expectedOutputArchivePath))
+        assertEmptyDirTasksTriggered(result)
+
+        where:
+        buildTaskName       | expectedOutputArchivePath
+        "buildDarwinZip"    | "darwin-zip/build/distributions/elasticsearch.zip"
+        "buildOssDarwinZip" | "oss-darwin-zip/build/distributions/elasticsearch-oss.zip"
+    }
+
+    def "registered distribution provides archives and directory variant"() {
+        given:
+        file('someFile.txt') << "some content"
+
+        settingsFile << """
+            include ':consumer'
+            include ':producer-tar'
+        """
+
+        buildFile << """
+        import org.gradle.api.artifacts.type.ArtifactTypeDefinition;
+        import org.gradle.api.internal.artifacts.ArtifactAttributes;
+
+        distribution_archives {
+            producerTar {
+                content {
+                    project.copySpec {
+                        from 'someFile.txt'
+                    }
+                }
+            }
+        }
+        
+        project('consumer') { p ->
+            configurations {
+                consumeArchive {}
+                consumeDir {}
+            }
+            
+            dependencies {
+                consumeDir project(path: ':producer-tar', configuration:'extracted')
+                consumeArchive project(path: ':producer-tar', configuration:'default' )
+            }
+            
+            tasks.register("copyDir", Copy) {
+                from(configurations.consumeDir)
+                into('build/dir')
+            }
+            
+            tasks.register("copyArchive", Copy) {
+                from(configurations.consumeArchive)
+                into('build/archives')
+            }
+        }
+        """
+        when:
+        def result = gradleRunner("copyArchive").build()
+
+        then:"tar task executed and target folder contains plain tar"
+        result.task(':buildProducerTar').outcome == TaskOutcome.SUCCESS
+        result.task(':consumer:copyArchive').outcome == TaskOutcome.SUCCESS
+        file("producer-tar/build/distributions/elasticsearch.tar.gz").exists()
+        file("consumer/build/archives/elasticsearch.tar.gz").exists()
+
+        when:
+        result = gradleRunner("copyDir").build()
+        then:"plain copy task executed and target folder contains plain content"
+        result.task(':buildProducer').outcome == TaskOutcome.SUCCESS
+        result.task(':consumer:copyDir').outcome == TaskOutcome.SUCCESS
+        file("producer-tar/build/install/someFile.txt").exists()
+        file("consumer/build/dir/someFile.txt").exists()
+    }
+
+    private static boolean assertTarPermissionDefaults(File tarArchive) {
+        TarArchiveInputStream tarInput = new TarArchiveInputStream(new GzipCompressorInputStream(new FileInputStream(tarArchive)))
+        try {
+            TarArchiveEntry currentEntry = tarInput.getNextTarEntry()
+            while (currentEntry != null) {
+                if (currentEntry.isDirectory()) {
+                    assertDefaultDirPermissions(currentEntry.getMode())
+                } else {
+                    assertDefaultFilePermissions(currentEntry.getMode())
+                }
+                currentEntry = tarInput.getNextTarEntry()
+            }
+            return true
+        } finally {
+            tarInput.close()
+        }
+    }
+
+    private static boolean assertZipPermissionDefaults(File archive) {
+        ZipFile zip = new ZipFile(archive)
+        try {
+            Enumeration<ZipEntry> entries = zip.getEntries()
+            while (entries.hasMoreElements()) {
+                ZipEntry zipEntry = entries.nextElement()
+                if (zipEntry.isDirectory()) {
+                    assertDefaultDirPermissions(zipEntry.getUnixMode())
+                } else {
+                    assertDefaultFilePermissions(zipEntry.getUnixMode())
+                }
+            }
+        } finally {
+            zip.close()
+        }
+        true
+    }
+
+    private static boolean assertDefaultDirPermissions(int mode) {
+        assert ((mode >> 6) & 07) == 7
+        assert ((mode >> 3) & 07) == 5
+        assert ((mode >> 0) & 07) == 5
+        true
+    }
+
+    private static boolean assertDefaultFilePermissions(int mode) {
+        assert ((mode >> 6) & 07) == 6
+        assert ((mode >> 3) & 07) == 4
+        assert ((mode >> 0) & 07) == 4
+        true
+    }
+
+    private static boolean assertEmptyDirTasksTriggered(BuildResult result) {
+        result.task(":createJvmOptionsDir").outcome == TaskOutcome.SUCCESS
+        result.task(":createLogsDir").outcome == TaskOutcome.SUCCESS
+        result.task(":createPluginsDir").outcome == TaskOutcome.SUCCESS
+        true
+    }
+}

buildSrc/src/integTest/groovy/org/elasticsearch/gradle/internal/InternalDistributionDownloadPluginFuncTest.groovy

@@ -72,7 +72,7 @@ class InternalDistributionDownloadPluginFuncTest extends AbstractGradleFuncTest
         def result = gradleRunner("setupDistro", '-g', testProjectDir.newFolder('GUH').path).build()
 
         then:
-        result.task(":distribution:archives:linux-tar:buildTar").outcome == TaskOutcome.SUCCESS
+        result.task(":distribution:archives:linux-tar:buildExploded").outcome == TaskOutcome.SUCCESS
         result.task(":setupDistro").outcome == TaskOutcome.SUCCESS
         assertExtractedDistroIsCreated(distroVersion, "build/distro", 'current-marker.txt')
     }
@@ -183,14 +183,29 @@ class InternalDistributionDownloadPluginFuncTest extends AbstractGradleFuncTest
         def bwcSubProjectFolder = testProjectDir.newFolder("distribution", "archives", "linux-tar")
         new File(bwcSubProjectFolder, 'current-marker.txt') << "current"
         new File(bwcSubProjectFolder, 'build.gradle') << """
+            import org.gradle.api.internal.artifacts.ArtifactAttributes;
+
             apply plugin:'distribution'
-            tasks.register("buildTar", Tar) {
+
+            def buildTar = tasks.register("buildTar", Tar) {
                 from('current-marker.txt')
                 archiveExtension = "tar.gz"
                 compression = Compression.GZIP
             }
+            def buildExploded = tasks.register("buildExploded", Copy) {
+                from('current-marker.txt')
+                into("build/local")
+            }
+            configurations {
+                extracted {
+                    attributes {
+                          attribute(ArtifactAttributes.ARTIFACT_FORMAT, "directory")
+                    }
+                }
+            }
             artifacts {
                 it.add("default", buildTar)
+                it.add("extracted", buildExploded)
             }
         """
         buildFile << """

buildSrc/src/main/groovy/org/elasticsearch/gradle/plugin/PluginBuildPlugin.groovy

@@ -25,7 +25,6 @@ import org.elasticsearch.gradle.Version
 import org.elasticsearch.gradle.VersionProperties
 import org.elasticsearch.gradle.dependencies.CompileOnlyResolvePlugin
 import org.elasticsearch.gradle.info.BuildParams
-import org.elasticsearch.gradle.test.RestIntegTestTask
 import org.elasticsearch.gradle.test.RestTestBasePlugin
 import org.elasticsearch.gradle.testclusters.RunTask
 import org.elasticsearch.gradle.util.Util
@@ -60,16 +59,7 @@ class PluginBuildPlugin implements Plugin<Project> {
         boolean isXPackModule = project.path.startsWith(':x-pack:plugin')
         boolean isModule = project.path.startsWith(':modules:') || isXPackModule
 
-        createIntegTestTask(project)
         createBundleTasks(project, extension)
-        project.tasks.named("integTest").configure {
-            it.dependsOn(project.tasks.named("bundlePlugin"))
-        }
-        if (isModule) {
-            project.testClusters.integTest.module(project.tasks.bundlePlugin.archiveFile)
-        } else {
-            project.testClusters.integTest.plugin(project.tasks.bundlePlugin.archiveFile)
-        }
 
         project.afterEvaluate {
             project.extensions.getByType(PluginPropertiesExtension).extendedPlugins.each { pluginName ->
@@ -116,14 +106,6 @@ class PluginBuildPlugin implements Plugin<Project> {
             }
         }
 
-        //disable integTest task if project has been converted to use yaml or java rest test plugin
-        project.pluginManager.withPlugin("elasticsearch.yaml-rest-test") {
-            project.tasks.integTest.enabled = false
-        }
-        project.pluginManager.withPlugin("elasticsearch.java-rest-test") {
-            project.tasks.integTest.enabled = false
-        }
-
         project.tasks.named('testingConventions').configure {
             naming.clear()
             naming {
@@ -142,7 +124,6 @@ class PluginBuildPlugin implements Plugin<Project> {
         // allow running ES with this plugin in the foreground of a build
         project.tasks.register('run', RunTask) {
             dependsOn(project.tasks.bundlePlugin)
-            useCluster project.testClusters.integTest
         }
     }
 
@@ -172,13 +153,6 @@ class PluginBuildPlugin implements Plugin<Project> {
         }
     }
 
-    /** Adds an integTest task which runs rest tests */
-    private static void createIntegTestTask(Project project) {
-        RestIntegTestTask integTest = project.tasks.create('integTest', RestIntegTestTask.class)
-        integTest.mustRunAfter('precommit', 'test')
-        project.check.dependsOn(integTest)
-    }
-
     /**
      * Adds a bundlePlugin task which builds the zip containing the plugin jars,
      * metadata, properties, and packaging files

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

@@ -0,0 +1,48 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch 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.elasticsearch.gradle;
+
+public interface DistributionDependency {
+    static DistributionDependency of(String dependencyNotation) {
+        return new StringBasedDistributionDependency(dependencyNotation);
+    }
+
+    Object getDefaultNotation();
+
+    Object getExtractedNotation();
+
+    class StringBasedDistributionDependency implements DistributionDependency {
+        private final String notation;
+
+        public StringBasedDistributionDependency(String notation) {
+            this.notation = notation;
+        }
+
+        @Override
+        public Object getDefaultNotation() {
+            return notation;
+        }
+
+        @Override
+        public Object getExtractedNotation() {
+            return notation;
+        }
+    }
+}