Require vespaversion, if set, to not be higher than parent (assumed hosted)

2 files changed, 86 insertions, 3 deletions

diff --git a/vespa-application-maven-plugin/src/main/java/com/yahoo/container/plugin/mojo/ApplicationMojo.java b/vespa-application-maven-plugin/src/main/java/com/yahoo/container/plugin/mojo/ApplicationMojo.java
index 1bbdfc9914a..101114db106 100644
--- a/vespa-application-maven-plugin/src/main/java/com/yahoo/container/plugin/mojo/ApplicationMojo.java
+++ b/vespa-application-maven-plugin/src/main/java/com/yahoo/container/plugin/mojo/ApplicationMojo.java
@@ -59,11 +59,14 @@ public class ApplicationMojo extends AbstractMojo {
         if ( ! applicationDestination.exists())
             return;
 
-        if (vespaversion == null) // Get the build version of the parent project unless specifically set.
-            vespaversion = project.getProperties().getProperty("vespaversion");
+         // Compile version is the build version of the parent project, unless specifically set.
+        Version parentVersion = Version.from(project.getParent().getVersion());
+        Version compileVersion = vespaversion == null ? parentVersion : Version.from(vespaversion);
+        if (parentVersion.compareTo(compileVersion) < 0)
+            throw new IllegalArgumentException("compile version (" + compileVersion + ") cannot be higher than parent version (" + parentVersion + ")");
 
         String metaData = String.format("{\"compileVersion\": \"%s\",\n \"buildTime\": %d}",
-                                        vespaversion,
+                                        compileVersion,
                                         System.currentTimeMillis());
         try {
             Files.write(applicationDestination.toPath().resolve("build-meta.json"),
diff --git a/vespa-application-maven-plugin/src/main/java/com/yahoo/container/plugin/mojo/Version.java b/vespa-application-maven-plugin/src/main/java/com/yahoo/container/plugin/mojo/Version.java
new file mode 100644
index 00000000000..050871043ca
--- /dev/null
+++ b/vespa-application-maven-plugin/src/main/java/com/yahoo/container/plugin/mojo/Version.java
@@ -0,0 +1,80 @@
+package com.yahoo.container.plugin.mojo;
+
+import java.util.Comparator;
+import java.util.Objects;
+
+import static java.lang.Integer.min;
+import static java.lang.Integer.parseInt;
+
+/**
+ * @author jonmv
+ */
+public class Version implements Comparable<Version> {
+
+    private static final Comparator<Version> comparator = Comparator.comparingInt(Version::major)
+                                                                    .thenComparing(Version::isSnapshot)
+                                                                    .thenComparing(Version::minor)
+                                                                    .thenComparing(Version::micro);
+
+    private final int major;
+    private final int minor;
+    private final int micro;
+    private final boolean snapshot;
+
+    private Version(int major, int minor, int micro, boolean snapshot) {
+        if (major < 0 || minor < 0 || micro < 0) throw new IllegalArgumentException("version numbers must all be non-negative");
+        this.major = major;
+        this.minor = minor;
+        this.micro = micro;
+        this.snapshot = snapshot;
+    }
+
+    public static Version of(int major, int minor, int micro) {
+        return new Version(major, minor, micro, false);
+    }
+
+    public static Version ofSnapshot(int major) {
+        return new Version(major, 0, 0, true);
+    }
+
+    public static Version from(String version) {
+        if (version.endsWith("-SNAPSHOT")) {
+            String[] parts = version.split("-");
+            if (parts.length != 2) throw new IllegalArgumentException("snapshot version must only specify major, e.g., \"1-SNAPSHOT\"");
+            return ofSnapshot(parseInt(parts[0]));
+        }
+        String[] parts = version.split("\\.");
+        if (parts.length != 3) throw new IllegalArgumentException("release versions must specify major, minor and micro, separated by '.', e.g., \"1.2.0\"");
+        return of(parseInt(parts[0]), parseInt(parts[1]), parseInt(parts[2]));
+    }
+
+    public int major() { return major; }
+    public int minor() { return minor; }
+    public int micro() { return micro; }
+    public boolean isSnapshot() { return snapshot; }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Version version = (Version) o;
+        return major == version.major && minor == version.minor && micro == version.micro && snapshot == version.snapshot;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(major, minor, micro, snapshot);
+    }
+
+    /** Snapshots sort last within their major, and sorting is on major, then minor, then micro otherwise. */
+    @Override
+    public int compareTo(Version other) {
+        return comparator.compare(this, other);
+    }
+
+    @Override
+    public String toString() {
+        return isSnapshot() ? major + "-SNAPSHOT" : major + "." + minor + "." + micro;
+    }
+
+}