check git version in GitRepository#isWorking() (#2681)

fixes #2664

Author: tulinkry

dev/before

@@ -4,10 +4,10 @@ echo "Environment variables:"
 env | sort
 
 echo "SCM versions:"
-if `which bk`; then bk --version; fi
-if `which hg`; then hg --version; fi
-if `which git`; then git --version; fi
-if `which svn`; then svn --version; fi
-if `which cvs`; then cvs --version; fi
-if `which mtn`; then mtn --version; fi
-if `which bzr`; then bzr version; fi
+if command -v bk; then bk --version; fi
+if command -v hg; then hg --version; fi
+if command -v git; then git --version; fi
+if command -v svn; then svn --version; fi
+if command -v cvs; then cvs --version; fi
+if command -v mtn; then mtn --version; fi
+if command -v bzr; then bzr version; fi

opengrok-indexer/src/main/java/org/opengrok/indexer/history/GitRepository.java

@@ -47,6 +47,7 @@
 import org.opengrok.indexer.util.BufferSink;
 import org.opengrok.indexer.util.Executor;
 import org.opengrok.indexer.util.StringUtils;
+import org.opengrok.indexer.util.Version;
 
 /**
  * Access to a Git repository.
@@ -85,6 +86,13 @@ public class GitRepository extends Repository {
      */
     private static final String GIT_DATE_OPT = "--date=iso8601-strict";
 
+    /**
+     * Minimum git version which supports the date format
+     *
+     * @see #GIT_DATE_OPT
+     */
+    private static final Version MINIMUM_VERSION = new Version(2, 1, 2);
+
     public GitRepository() {
         type = "git";
         /*
@@ -521,8 +529,22 @@ boolean supportsSubRepositories() {
     public boolean isWorking() {
         if (working == null) {
             ensureCommand(CMD_PROPERTY_KEY, CMD_FALLBACK);
-            working = checkCmd(RepoCommand, "--help");
+            Executor exec = new Executor(new String[]{RepoCommand, "--version"});
+
+            if (exec.exec(false) == 0) {
+                final String outputVersion = exec.getOutputString();
+                final String version = outputVersion.replaceAll(".*? version (\\d+(\\.\\d+)*).*", "$1");
+                try {
+                    working = Version.from(version).compareTo(MINIMUM_VERSION) >= 0;
+                } catch (NumberFormatException ex) {
+                    LOGGER.log(Level.WARNING, String.format("Unable to detect git version from %s", outputVersion), ex);
+                    working = false;
+                }
+            } else {
+                working = false;
+            }
         }
+
         return working;
     }
 

opengrok-indexer/src/main/java/org/opengrok/indexer/util/Version.java

@@ -0,0 +1,123 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * See LICENSE.txt included in this distribution for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at LICENSE.txt.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Portions Copyright (c) 2019, Krystof Tulinger (tulinkry).
+ */
+package org.opengrok.indexer.util;
+
+import java.util.Arrays;
+import java.util.stream.Stream;
+
+/**
+ * This class implements portions of semantic versioning from version noted as
+ * <pre>
+ *     a.b.c.d.e.f
+ * </pre>
+ * where
+ * <pre>
+ *     a - major
+ *     b - minor
+ *     c - patch
+ *     d ... - others
+ * </pre>
+ *
+ * @author Krystof Tulinger (tulinkry)
+ * @see <a href="https://semver.org/">https://semver.org/</a>
+ */
+public class Version implements Comparable<Version> {
+    private final Integer[] versions;
+
+    /**
+     * Construct the version from integer parts.
+     * The order is:
+     * <ol>
+     * <li>major</li>
+     * <li>minor</li>
+     * <li>patch</li>
+     * <li>... others</li>
+     * </ol>
+     *
+     * @param parts integer values for version partials
+     */
+    public Version(Integer... parts) {
+        // cut off trailing zeros
+        int cutOffLength = parts.length;
+        for (int i = parts.length - 1; i >= 0; i--) {
+            if (parts[i] != 0) {
+                break;
+            }
+            cutOffLength--;
+        }
+        versions = Arrays.copyOf(parts, cutOffLength);
+    }
+
+    /**
+     * Construct the version from a string.
+     *
+     * @param string string representing the version (e. g. 1.2.1)
+     * @return the new instance of version from the string
+     * @throws NumberFormatException when parts can not be converted to integers
+     */
+    public static Version from(String string) throws NumberFormatException {
+        return new Version(
+                Stream.of(string.trim().split("\\."))
+                      .map(String::trim)
+                      .map(Integer::parseInt)
+                      .toArray(Integer[]::new)
+        );
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Version version = (Version) o;
+        return Arrays.equals(versions, version.versions);
+    }
+
+    @Override
+    public int hashCode() {
+        return Arrays.hashCode(versions);
+    }
+
+    @Override
+    public int compareTo(Version o) {
+        if (o == null) {
+            return 1;
+        }
+
+        // first different number determines the result
+        for (int i = 0; i < Math.min(versions.length, o.versions.length); i++) {
+            if (!versions[i].equals(o.versions[i])) {
+                return Integer.compare(versions[i], o.versions[i]);
+            }
+        }
+
+        // the comparable parts are the same, the longer has some trailing non-null element which
+        // makes it greater then the shorter
+        // e. g. 1.0.0.0.1 vs. 1.0.0
+        return Integer.compare(versions.length, o.versions.length);
+    }
+}

opengrok-indexer/src/test/java/org/opengrok/indexer/util/VersionTest.java

@@ -0,0 +1,89 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * See LICENSE.txt included in this distribution for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at LICENSE.txt.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Portions Copyright (c) 2019, Krystof Tulinger (tulinkry).
+ */
+package org.opengrok.indexer.util;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class VersionTest {
+
+    @Test
+    public void testFromString() {
+        Assert.assertEquals(new Version(1, 2, 1), Version.from("1.2.   1    "));
+        Assert.assertEquals(new Version(3, 2, 6), Version.from("   3.  2.6"));
+        Assert.assertEquals(new Version(100, 200, 104), Version.from("100.   200.   104"));
+        Assert.assertEquals(new Version(1), Version.from("   1    "));
+    }
+
+    @Test(expected = NumberFormatException.class)
+    public void testFromEmptyString() {
+        Version.from("");
+    }
+
+
+    @Test(expected = NumberFormatException.class)
+    public void testFromInvalidString() {
+        Version.from("1.2.abcd.2");
+    }
+
+    @Test
+    public void testLowerComparsion() {
+        Assert.assertTrue(new Version(1).compareTo(new Version(2)) < 0);
+        Assert.assertTrue(new Version(1).compareTo(new Version(20)) < 0);
+        Assert.assertTrue(new Version(1, 2).compareTo(new Version(1, 3)) < 0);
+        Assert.assertTrue(new Version(1, 2).compareTo(new Version(2)) < 0);
+        Assert.assertTrue(new Version(1, 2).compareTo(new Version(1, 100)) < 0);
+        Assert.assertTrue(new Version(1, 2, 3).compareTo(new Version(1, 3)) < 0);
+        Assert.assertTrue(new Version(1, 2, 3).compareTo(new Version(1, 2, 4)) < 0);
+        Assert.assertTrue(new Version(2, 1, 2).compareTo(new Version(2, 11, 0)) < 0);
+        Assert.assertTrue(new Version(2, 1, 2).compareTo(new Version(2, 20, 1)) < 0);
+        Assert.assertTrue(new Version(1, 0, 0).compareTo(new Version(1, 0, 0, 0, 0, 1)) < 0);
+    }
+
+    @Test
+    public void testGreaterComparsion() {
+        Assert.assertTrue(new Version(2).compareTo(new Version(1)) > 0);
+        Assert.assertTrue(new Version(20).compareTo(new Version(1)) > 0);
+        Assert.assertTrue(new Version(1, 3).compareTo(new Version(1, 2)) > 0);
+        Assert.assertTrue(new Version(2).compareTo(new Version(1, 2)) > 0);
+        Assert.assertTrue(new Version(1, 100).compareTo(new Version(1, 2)) > 0);
+        Assert.assertTrue(new Version(1, 3).compareTo(new Version(1, 2, 3)) > 0);
+        Assert.assertTrue(new Version(1, 2, 4).compareTo(new Version(1, 2, 3)) > 0);
+        Assert.assertTrue(new Version(2, 11, 0).compareTo(new Version(2, 1, 2)) > 0);
+        Assert.assertTrue(new Version(2, 20, 1).compareTo(new Version(2, 1, 2)) > 0);
+        Assert.assertTrue(new Version(1, 0, 0, 0, 0, 1).compareTo(new Version(1, 0, 0)) > 0);
+    }
+
+    @Test
+    public void testEqualsComparsion() {
+        Assert.assertTrue(new Version(1).compareTo(new Version(1)) == 0);
+        Assert.assertTrue(new Version(1, 3).compareTo(new Version(1, 3)) == 0);
+        Assert.assertTrue(new Version(1, 2).compareTo(new Version(1, 2)) == 0);
+        Assert.assertTrue(new Version(1, 100).compareTo(new Version(1, 100)) == 0);
+        Assert.assertTrue(new Version(1, 2, 3).compareTo(new Version(1, 2, 3)) == 0);
+        Assert.assertTrue(new Version(1, 2, 4).compareTo(new Version(1, 2, 4)) == 0);
+        Assert.assertTrue(new Version(1, 0, 0).compareTo(new Version(1, 0, 0)) == 0);
+        Assert.assertTrue(new Version(1, 0, 0).compareTo(new Version(1, 0, 0, 0, 0)) == 0);
+    }
+}