Make the build version qualifier aware

build.gradle

@@ -51,7 +51,7 @@ subprojects {
 
 apply plugin: 'nebula.info-scm'
 String licenseCommit
-if (VersionProperties.elasticsearch.toString().endsWith('-SNAPSHOT')) {
+if (VersionProperties.elasticsearch.isSnapshot()) {
   licenseCommit = scminfo.change ?: "master" // leniency for non git builds
 } else {
   licenseCommit = "v${version}"
@@ -102,7 +102,7 @@ subprojects {
  * in a branch if there are only betas and rcs in the branch so we have
  * *something* to test against. */
 VersionCollection versions = new VersionCollection(file('server/src/main/java/org/elasticsearch/Version.java').readLines('UTF-8'))
-if (versions.currentVersion != VersionProperties.elasticsearch) {
+if (versions.currentVersion.isSameVersionNumber(VersionProperties.elasticsearch) == false) {
   throw new GradleException("The last version in Versions.java [${versions.currentVersion}] does not match " +
           "VersionProperties.elasticsearch [${VersionProperties.elasticsearch}]")
 }

buildSrc/build.gradle

@@ -16,8 +16,6 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import java.nio.file.Files
-
 plugins {
   id 'java-gradle-plugin'
   id 'groovy'
@@ -52,33 +50,8 @@ sourceCompatibility = minimumRuntimeVersion
 
 Properties props = new Properties()
 props.load(project.file('version.properties').newDataInputStream())
-version = props.getProperty('elasticsearch')
-boolean snapshot = "true".equals(System.getProperty("build.snapshot", "true"));
-if (snapshot) {
-  // we update the version property to reflect if we are building a snapshot or a release build
-  // we write this back out below to load it in the Build.java which will be shown in rest main action
-  // to indicate this being a snapshot build or a release build.
-  version += "-SNAPSHOT"
-  props.put("elasticsearch", version);
-}
-
-File tempPropertiesFile = new File(project.buildDir, "version.properties")
-task writeVersionProperties {
-  inputs.properties(props)
-  outputs.file(tempPropertiesFile)
-  doLast {
-    OutputStream stream = Files.newOutputStream(tempPropertiesFile.toPath());
-    try {
-      props.store(stream, "UTF-8");
-    } finally {
-      stream.close();
-    }
-  }
-}
-
 processResources {
-  dependsOn writeVersionProperties
-  from tempPropertiesFile
+  from file('version.properties')
 }
 
 /*****************************************************************************

buildSrc/src/main/groovy/org/elasticsearch/gradle/BuildPlugin.groovy

@@ -696,18 +696,13 @@ class BuildPlugin implements Plugin<Project> {
             jarTask.destinationDir = new File(project.buildDir, 'distributions')
             // fixup the jar manifest
             jarTask.doFirst {
-                final Version versionWithoutSnapshot = new Version(
-                        VersionProperties.elasticsearch.major,
-                        VersionProperties.elasticsearch.minor,
-                        VersionProperties.elasticsearch.revision,
-                        VersionProperties.elasticsearch.suffix,
-                        false)
                 // this doFirst is added before the info plugin, therefore it will run
                 // after the doFirst added by the info plugin, and we can override attributes
                 jarTask.manifest.attributes(
-                        'X-Compile-Elasticsearch-Version': versionWithoutSnapshot,
-                        'X-Compile-Lucene-Version': VersionProperties.lucene,
+                        'X-Compile-Elasticsearch-Version': VersionProperties.elasticsearch.dropSnapshot().dropQualifier(),
+                        'X-Compile-Elasticsearch-Qualifier': VersionProperties.elasticsearch.qualifier,
                         'X-Compile-Elasticsearch-Snapshot': VersionProperties.elasticsearch.isSnapshot(),
+                        'X-Compile-Lucene-Version': VersionProperties.lucene,
                         'Build-Date': ZonedDateTime.now(ZoneOffset.UTC),
                         'Build-Java-Version': project.compilerJavaVersion)
                 if (jarTask.manifest.attributes.containsKey('Change') == false) {

buildSrc/src/main/groovy/org/elasticsearch/gradle/VersionCollection.groovy

@@ -47,11 +47,13 @@ import java.util.regex.Matcher
  * Notes on terminology:
  * - The case for major+1 being released is accomplished through the isReleasableBranch value. If this is false, then the branch is no longer
  *   releasable, meaning not to test against any snapshots.
- * - Released is defined as having > 1 suffix-free version in a major.minor series. For instance, only 6.2.0 means unreleased, but a
+ * - Released is defined as having > 1 qualifier-free version in a major.minor series. For instance, only 6.2.0 means unreleased, but a
  *   6.2.0 and 6.2.1 mean that 6.2.0 was released already.
  */
 class VersionCollection {
 
+    public static final int LAST_RELEASED_MAJOR = 6
+
     private final List<Version> versions
     Version nextMinorSnapshot
     Version stagedMinorSnapshot
@@ -93,15 +95,15 @@ class VersionCollection {
         }
 
         // If the major version has been released, then remove all of the alpha/beta/rc versions that exist in the set
-        versionSet.removeAll { it.suffix.isEmpty() == false && isMajorReleased(it, versionSet) }
+        versionSet.removeAll { it.qualifier.isEmpty() == false && isMajorReleased(it, versionSet) }
 
         // set currentVersion
         Version lastVersion = versionSet.last()
-        currentVersion = new Version(lastVersion.major, lastVersion.minor, lastVersion.revision, lastVersion.suffix, buildSnapshot)
+        currentVersion = new Version(lastVersion.major, lastVersion.minor, lastVersion.revision, lastVersion.qualifier, buildSnapshot)
 
         // remove all of the potential alpha/beta/rc from the currentVersion
         versionSet.removeAll {
-            it.suffix.isEmpty() == false &&
+            it.qualifier.isEmpty() == false &&
             it.major == currentVersion.major &&
             it.minor == currentVersion.minor &&
             it.revision == currentVersion.revision }
@@ -281,10 +283,14 @@ class VersionCollection {
      * This means that there is more than just a major.0.0 or major.0.0-alpha in a branch to signify it has been prevously released.
      */
     private boolean isMajorReleased(Version version, TreeSet<Version> items) {
+        if (version.getMajor() <= LAST_RELEASED_MAJOR) {
+            // TODO: Starting with 7.0.0 we no longer store qualifiers in Version.java we are not able to tell from qualifiers
+            return true
+        }
         return items
             .tailSet(Version.fromString("${version.major}.0.0"))
             .headSet(Version.fromString("${version.major + 1}.0.0"))
-            .count { it.suffix.isEmpty() }  // count only non suffix'd versions as actual versions that may be released
+            .count { it.qualifier.isEmpty() }  // count only non qualifier'd versions as actual versions that may be released
             .intValue() > 1
     }
 
@@ -301,7 +307,7 @@ class VersionCollection {
      */
     private Version replaceAsSnapshot(Version version) {
         versionSet.remove(version)
-        Version snapshotVersion = new Version(version.major, version.minor, version.revision, version.suffix, true)
+        Version snapshotVersion = new Version(version.major, version.minor, version.revision, version.qualifier, true)
         safeAddToSet(snapshotVersion)
         return snapshotVersion
     }

buildSrc/src/main/groovy/org/elasticsearch/gradle/doc/DocsTestPlugin.groovy

@@ -42,8 +42,8 @@ public class DocsTestPlugin extends RestTestPlugin {
              * the values may differ. In particular {version} needs to resolve
              * to the version being built for testing but needs to resolve to
              * the last released version for docs. */
-            '\\{version\\}':
-                VersionProperties.elasticsearch.toString().replace('-SNAPSHOT', ''),
+            '\\{version\\}': VersionProperties.elasticsearch.dropQualifier().dropSnapshot().toString(),
+            '\\{plugin_version\\}': VersionProperties.elasticsearch.toString(),
             '\\{lucene_version\\}' : VersionProperties.lucene.replaceAll('-snapshot-\\w+$', ''),
             '\\{build_flavor\\}' :
                 project.integTestCluster.distribution.startsWith('oss-') ? 'oss' : 'default',

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

@@ -67,17 +67,11 @@ class PluginPropertiesTask extends Copy {
     }
 
     Map<String, String> generateSubstitutions() {
-        def stringSnap = { version ->
-            if (version.endsWith("-SNAPSHOT")) {
-               return version.substring(0, version.length() - 9)
-            }
-            return version
-        }
         return [
             'name': extension.name,
             'description': extension.description,
-            'version': stringSnap(extension.version),
-            'elasticsearchVersion': stringSnap(VersionProperties.elasticsearch.toString()),
+            'version': extension.version as String,
+            'elasticsearchVersion': VersionProperties.elasticsearch.dropQualifier().dropSnapshot() as String,
             'javaVersion': project.targetCompatibility as String,
             'classname': extension.classname,
             'extendedPlugins': extension.extendedPlugins.join(','),

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

@@ -16,35 +16,43 @@ public final class Version implements Comparable<Version> {
     /**
      * Suffix on the version name.
      */
-    private final String suffix;
+    private final String qualifier;
 
     private static final Pattern pattern =
             Pattern.compile("(\\d)+\\.(\\d+)\\.(\\d+)(-alpha\\d+|-beta\\d+|-rc\\d+)?(-SNAPSHOT)?");
 
-    public Version(int major, int minor, int revision, String suffix, boolean snapshot) {
+    Version(int major, int minor, int revision, String qualifier, boolean snapshot) {
         Objects.requireNonNull(major, "major version can't be null");
         Objects.requireNonNull(minor, "minor version can't be null");
         Objects.requireNonNull(revision, "revision version can't be null");
         this.major = major;
         this.minor = minor;
         this.revision = revision;
         this.snapshot = snapshot;
-        this.suffix = suffix == null ? "" : suffix;
+        if (qualifier == null || qualifier.isEmpty()) {
+            this.qualifier = "";
+        } else if (qualifier.startsWith("-")) {
+            this.qualifier = qualifier;
+        } else {
+            this.qualifier = "-" + qualifier;
+        }
 
         int suffixOffset = 0;
-        if (this.suffix.isEmpty()) {
-            // no suffix will be considered smaller, uncomment to change that
+        if (this.qualifier.isEmpty()) {
+            // no qualifier will be considered smaller, uncomment to change that
             // suffixOffset = 100;
         } else {
-            if (this.suffix.contains("alpha")) {
-                suffixOffset += parseSuffixNumber(this.suffix.substring(6));
-            } else if (this.suffix.contains("beta")) {
-                suffixOffset += 25 + parseSuffixNumber(this.suffix.substring(5));
-            } else if (this.suffix.contains("rc")) {
-                suffixOffset += 50 + parseSuffixNumber(this.suffix.substring(3));
+            if (this.qualifier.contains("alpha")) {
+                suffixOffset += parseSuffixNumber(this.qualifier.substring(6));
+            } else if (this.qualifier.contains("beta")) {
+                suffixOffset += 25 + parseSuffixNumber(this.qualifier.substring(5));
+            } else if (this.qualifier.contains("rc")) {
+                suffixOffset += 50 + parseSuffixNumber(this.qualifier.substring(3));
             }
             else {
-                throw new IllegalArgumentException("Suffix must contain one of: alpha, beta or rc");
+                throw new IllegalArgumentException(
+                    "Suffix must contain one of: alpha, beta or rc instead of: " + this.qualifier
+                );
             }
         }
 
@@ -54,7 +62,7 @@ public Version(int major, int minor, int revision, String suffix, boolean snapsh
 
     private static int parseSuffixNumber(String substring) {
         if (substring.isEmpty()) {
-            throw new IllegalArgumentException("Invalid suffix, must contain a number e.x. alpha2");
+            throw new IllegalArgumentException("Invalid qualifier, must contain a number e.x. alpha2");
         }
         return Integer.parseInt(substring);
     }
@@ -81,7 +89,7 @@ public static Version fromString(final String s) {
     public String toString() {
         final String snapshotStr = snapshot ? "-SNAPSHOT" : "";
         return String.valueOf(getMajor()) + "." + String.valueOf(getMinor()) + "." + String.valueOf(getRevision()) +
-                (suffix == null ? "" : suffix) + snapshotStr;
+                (qualifier == null ? "" : qualifier) + snapshotStr;
     }
 
     public boolean before(Version compareTo) {
@@ -121,12 +129,12 @@ public boolean onOrBeforeIncludingSuffix(Version otherVersion) {
             return id < otherVersion.getId();
         }
 
-        if (suffix.equals("")) {
-            return otherVersion.getSuffix().equals("");
+        if (qualifier.equals("")) {
+            return otherVersion.getQualifier().equals("");
         }
 
 
-        return otherVersion.getSuffix().equals("") || suffix.compareTo(otherVersion.getSuffix()) < 0;
+        return otherVersion.getQualifier().equals("") || qualifier.compareTo(otherVersion.getQualifier()) < 0;
     }
 
     @Override
@@ -139,13 +147,27 @@ public boolean equals(Object o) {
                 revision == version.revision &&
                 id == version.id &&
                 snapshot == version.snapshot &&
-                Objects.equals(suffix, version.suffix);
+                Objects.equals(qualifier, version.qualifier);
     }
 
     @Override
     public int hashCode() {
 
-        return Objects.hash(major, minor, revision, id, snapshot, suffix);
+        return Objects.hash(major, minor, revision, id, snapshot, qualifier);
+    }
+
+    public boolean isSameVersionNumber(Version other) {
+        return major == other.major &&
+            minor == other.minor &&
+            revision == other.revision;
+    }
+
+    public Version dropQualifier() {
+        return new Version(major, minor, revision, "", snapshot);
+    }
+
+    public Version dropSnapshot() {
+        return new Version(major, minor, revision, qualifier, false);
     }
 
     public int getMajor() {
@@ -168,8 +190,8 @@ public boolean isSnapshot() {
         return snapshot;
     }
 
-    public String getSuffix() {
-        return suffix;
+    public String getQualifier() {
+        return qualifier;
     }
 
     @Override

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

@@ -27,11 +27,29 @@ public static Map<String, String> getVersions() {
     private static final Map<String, String> versions = new HashMap<String, String>();
     static {
         Properties props = getVersionProperties();
-        elasticsearch = Version.fromString(props.getProperty("elasticsearch"));
+        Version baseVersion = Version.fromString(props.getProperty("elasticsearch"));
+        if (baseVersion.isSnapshot()) {
+            throw new IllegalArgumentException("version.properties can't contain a snapshot version for elasticsearch. " +
+                "Use the `build.snapshot` property instead.");
+        }
+        if (baseVersion.getQualifier().isEmpty() == false) {
+            throw new IllegalArgumentException("version.properties can't contain a version qualifier for elasticsearch." +
+                "Use the `build.version_qualifier` property instead.");
+        }
+        elasticsearch = new Version(
+            baseVersion.getMajor(),
+            baseVersion.getMinor(),
+            baseVersion.getRevision(),
+            // TODO: Change default to "" after CI "warm-up" by adding -Dbuild.version_qualifier="" to ML jobs to produce
+            //       a snapshot.
+            System.getProperty("build.version_qualifier", "alpha1"),
+            Boolean.parseBoolean(System.getProperty("build.snapshot", "true"))
+        );
         lucene = props.getProperty("lucene");
         for (String property : props.stringPropertyNames()) {
             versions.put(property, props.getProperty(property));
         }
+        versions.put("elasticsearch", elasticsearch.toString());
     }
 
     private static Properties getVersionProperties() {