Make sure reports are not run in test environments

Author: flaix

src/main/java/com/gitblit/instance/GitblitInstance.java

@@ -1,9 +1,14 @@
 package com.gitblit.instance;
 
+import com.gitblit.IStoredSettings;
 import com.gitblit.manager.IRuntimeManager;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
 
 public class GitblitInstance
 {
+    private final static String STATS_URL = "https://instats.gitblit.dev/hiitsme/";
 
     private IRuntimeManager runtimeManager;
 
@@ -50,5 +55,95 @@ else if (runtimeManager.getStatus().isGO){
 
     public void start()
     {
+        if (shouldRunReports()) {
+            startReports();
+        }
+    }
+
+
+    /**
+     * Determine if the reporting task should run.
+     *
+     * We do not want to report anything, i.e. the reporting task to run,
+     * if we are running unit tests or integration tests.
+     * Instance reports should only be sent for production instances or released versions.
+     * Therefore we also check if the Gitblit version is a SNAPSHOT version,
+     * or if the docker image is not a release version, when running from a docker image.
+     * A docker image running under GOSS should also not report anything.
+     */
+    boolean shouldRunReports()
+    {
+        // We can only run reports when we have been initialized
+        if (this.report == null || this.runtimeManager == null) {
+            return false;
+        }
+
+        // Check if we are running in a test environment
+        IStoredSettings settings = this.runtimeManager.getSettings();
+        if (! settings.getString("gitblit.testReportingURL", "").isEmpty()) {
+            // Force reporting to run overriding any test settings
+            return true;
+        }
+        if (settings.getBoolean("gitblit.testRun", false)) {
+            return false;
+        }
+
+        // Check if we are running a SNAPSHOT version
+        if (this.runtimeManager.getStatus().version.endsWith("SNAPSHOT")) {
+            return false;
+        }
+
+        if (this.report.instanceStat.instanceType == GitblitInstanceStat.GitblitInstanceType.DOCKER) {
+            // Check if we are running a docker image that is not a release version
+            if (! settings.getString("container.imageType", "").equals("release")) {
+                return false;
+            }
+
+            // Check if we are running a docker image under GOSS
+            if (System.getenv("GITBLIT_GOSS_TEST") != null) {
+                return false;
+            }
+        }
+
+        return true;
     }
+
+
+    /**
+     * Start the reporting task.
+     *
+     * This will start a thread that runs once a day and sends the instance
+     * report to the popularity report server.
+     */
+    private void startReports()
+    {
+        this.executor = Executors.newSingleThreadScheduledExecutor();
+
+        String baseUrl = STATS_URL;
+        int delay = 24;
+        int period = 24 * 60; // 24 hours in minutes
+        TimeUnit unit = TimeUnit.MINUTES;
+
+        this.executor.scheduleAtFixedRate(new Runnable()
+        {
+            @Override
+            public void run()
+            {
+                sendMyStats(baseUrl + instanceId);
+            }
+        }, delay, period, unit);
+    }
+
+    /**
+     * Send the instance report to the popularity report server.
+     *
+     * This will send a JSON object to the server with the instance report.
+     *
+     * @param server
+     *            The URL to send the report to.
+     */
+    private void sendMyStats(String server)
+    {
+    }
+
 }

src/main/java/com/gitblit/models/ServerStatus.java

@@ -51,9 +51,9 @@ public class ServerStatus implements Serializable {
 
 	public String servletContainer;
 
-	public ServerStatus() {
+	public ServerStatus(String version) {
 		this.bootDate = new Date();
-		this.version = Constants.getVersion();
+		this.version = version;
 		this.releaseDate = Constants.getBuildDate();
 
 		this.heapMaximum = Runtime.getRuntime().maxMemory();
@@ -76,6 +76,10 @@ public ServerStatus() {
 		put("os.version");
 	}
 
+	public ServerStatus() {
+		this(Constants.getVersion());
+	}
+
 	private void put(String key) {
 		systemProperties.put(key, System.getProperty(key));
 	}

src/test/config/test-gitblit.properties

@@ -1,6 +1,7 @@
 #
 # Gitblit Unit Testing properties
 #
+gitblit.testRun = true
 git.allowAnonymousPushes = true
 git.defaultAccessRestriction = NONE
 git.repositoriesFolder = ${baseFolder}/git

src/test/java/com/gitblit/instance/GitblitInstanceTest.java

@@ -0,0 +1,64 @@
+package com.gitblit.instance;
+
+import com.gitblit.manager.IRuntimeManager;
+
+import com.gitblit.models.ServerStatus;
+import com.gitblit.tests.mock.MockRuntimeManager;
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+
+
+public class GitblitInstanceTest
+{
+    @Test
+    public void testShouldNotReportUnintialized()
+    {
+        GitblitInstance instance = new GitblitInstance();
+        assertFalse(instance.shouldRunReports());
+    }
+
+    @Test
+    public void testShouldNotReportInTests()
+    {
+        GitblitInstance instance = new GitblitInstance();
+        instance.init(new MockRuntimeManager());
+        assertFalse(instance.shouldRunReports());
+    }
+
+    @Test
+    public void testShouldNotReportInSnapshotVersion()
+    {
+        GitblitInstance instance = new GitblitInstance();
+        IRuntimeManager runtimeManager = new MockRuntimeManager();
+        runtimeManager.getSettings().overrideSetting("gitblit.testRun", "false");
+        instance.init(runtimeManager);
+        assertFalse(instance.shouldRunReports());
+    }
+
+    @Test
+    public void testShouldReportIfForced()
+    {
+        GitblitInstance instance = new GitblitInstance();
+        IRuntimeManager runtimeManager = new MockRuntimeManager();
+        runtimeManager.getSettings().overrideSetting("gitblit.testRunReporting", "true");
+        instance.init(runtimeManager);
+        assertTrue(instance.shouldRunReports());
+    }
+
+    @Test
+    public void testShouldReportInReleaseVersion()
+    {
+        ServerStatus serverStatus = new ServerStatus("1.10.123");
+        MockRuntimeManager runtimeManager = new MockRuntimeManager();
+        runtimeManager.setStatus(serverStatus);
+        runtimeManager.getSettings().overrideSetting("gitblit.testRun", "false");
+
+        GitblitInstance instance = new GitblitInstance();
+        instance.init(runtimeManager);
+        assertTrue(instance.shouldRunReports());
+    }
+
+}

src/test/java/com/gitblit/tests/GitBlitSuite.java

@@ -28,6 +28,7 @@
 
 import com.gitblit.instance.GitblitInstanceIdTest;
 import com.gitblit.instance.GitblitInstanceStatTest;
+import com.gitblit.instance.GitblitInstanceTest;
 import com.gitblit.utils.TimeUtilsTest;
 import org.eclipse.jgit.api.Git;
 import org.eclipse.jgit.lib.Repository;
@@ -77,7 +78,7 @@
 		BranchTicketServiceTest.class, RedisTicketServiceTest.class, AuthenticationManagerTest.class,
 		SshKeysDispatcherTest.class, UITicketTest.class, PathUtilsTest.class, SshKerberosAuthenticationTest.class,
 		GravatarTest.class, FilestoreManagerTest.class, FilestoreServletTest.class, TicketReferenceTest.class,
-		GitblitInstanceIdTest.class, GitblitInstanceStatTest.class })
+		GitblitInstanceIdTest.class, GitblitInstanceStatTest.class, GitblitInstanceTest.class })
 public class GitBlitSuite {
 
 	public static final File BASEFOLDER = new File("data");

src/test/java/com/gitblit/tests/GitblitUnitTest.java

@@ -31,7 +31,10 @@
 public class GitblitUnitTest extends org.junit.Assert {
 
 	public static IStoredSettings settings() {
-		return runtime().getSettings();
+		IStoredSettings settings = runtime().getSettings();
+		// Insert marker that this is running as a test
+		settings.overrideSetting("gitblit.testRun", "true");
+		return settings;
 	}
 
 	public static IRuntimeManager runtime() {

src/test/java/com/gitblit/tests/mock/MockRuntimeManager.java

@@ -52,6 +52,8 @@ public MockRuntimeManager(Map<String, Object> settings) {
 
 	public MockRuntimeManager(IStoredSettings settings) {
 		this.settings = settings;
+		// Insert marker that this is running as a test
+		settings.overrideSetting("gitblit.testRun", "true");
 
 		this.serverStatus = new ServerStatus();
 		this.serverStatus.servletContainer = "MockServer";
@@ -94,6 +96,11 @@ public Date getBootDate() {
 		return serverStatus.bootDate;
 	}
 
+	public void setStatus(ServerStatus status)
+	{
+		this.serverStatus = status;
+	}
+
 	@Override
 	public ServerStatus getStatus() {
 		// update heap memory status