Send diagnostics to tmc-bandicoot

Author: Redande

google_checks.xml

@@ -45,7 +45,7 @@
             <property name="allowNonPrintableEscapes" value="true"/>
         </module>
         <module name="LineLength">
-            <property name="max" value="100"/>
+            <property name="max" value="160"/>
             <property name="ignorePattern" value="^package.*|^import.*|a href|href|http://|https://|ftp://|//.*"/>
         </module>
         <module name="AvoidStarImport"/>

pom.xml

@@ -3,7 +3,7 @@
 
     <groupId>fi.helsinki.cs.tmc</groupId>
     <artifactId>core</artifactId>
-    <version>0.9.9-SNAPSHOT</version>
+    <version>0.9.10-SNAPSHOT</version>
     <packaging>jar</packaging>
     <name>tmc-core</name>
     <url>http://testmycode.net</url>

src/main/java/fi/helsinki/cs/tmc/core/TmcCore.java

@@ -12,6 +12,7 @@
 import fi.helsinki.cs.tmc.core.commands.RequestCodeReview;
 import fi.helsinki.cs.tmc.core.commands.RunCheckStyle;
 import fi.helsinki.cs.tmc.core.commands.RunTests;
+import fi.helsinki.cs.tmc.core.commands.SendDiagnostics;
 import fi.helsinki.cs.tmc.core.commands.SendFeedback;
 import fi.helsinki.cs.tmc.core.commands.SendSpywareEvents;
 import fi.helsinki.cs.tmc.core.commands.Submit;
@@ -25,6 +26,7 @@
 import fi.helsinki.cs.tmc.core.domain.submission.SubmissionResult;
 import fi.helsinki.cs.tmc.core.holders.TmcLangsHolder;
 import fi.helsinki.cs.tmc.core.holders.TmcSettingsHolder;
+import fi.helsinki.cs.tmc.core.utilities.ExceptionTrackingCallable;
 import fi.helsinki.cs.tmc.langs.abstraction.ValidationResult;
 import fi.helsinki.cs.tmc.langs.domain.RunResult;
 import fi.helsinki.cs.tmc.langs.util.TaskExecutor;
@@ -72,81 +74,88 @@ public TmcCore(TmcSettings settings, TaskExecutor tmcLangs) {
         TmcLangsHolder.set(tmcLangs);
     }
 
+    public Callable<Void> sendDiagnostics(
+            ProgressObserver observer) {
+        logger.info("Creating new SendDiagnostics command");
+        return new SendDiagnostics(observer);
+    }
+
     public Callable<List<Exercise>> downloadOrUpdateExercises(
             ProgressObserver observer, List<Exercise> exercises) {
         logger.info("Creating new DownloadOrUpdateExercises command");
-        return new DownloadOrUpdateExercises(observer, exercises);
+        return new ExceptionTrackingCallable<>(new DownloadOrUpdateExercises(observer, exercises));
     }
 
     // TODO: returns new course.
     public Callable<Course> getCourseDetails(ProgressObserver observer, Course course) {
         logger.info("Creating new GetCourseDetails command");
-        return new GetCourseDetails(observer, course);
+        return new ExceptionTrackingCallable<>(new GetCourseDetails(observer, course));
     }
 
     public Callable<List<Course>> listCourses(ProgressObserver observer) {
         logger.info("Creating new ListCourses command");
-        return new ListCourses(observer);
+        return new ExceptionTrackingCallable<>(new ListCourses(observer));
     }
 
     public Callable<URI> pasteWithComment(
             ProgressObserver observer, Exercise exercise, String message) {
         logger.info("Creating new PasteWithComment command");
-        return new PasteWithComment(observer, exercise, message);
+        return new ExceptionTrackingCallable<>(new PasteWithComment(observer, exercise, message));
     }
 
     public Callable<ValidationResult> runCheckStyle(ProgressObserver observer, Exercise exercise) {
         logger.info("Creating new RunCheckStyle command");
-        return new RunCheckStyle(observer, exercise);
+        return new ExceptionTrackingCallable<>(new RunCheckStyle(observer, exercise));
     }
 
     public Callable<RunResult> runTests(ProgressObserver observer, Exercise exercise) {
         logger.info("Creating new RunTests command");
-        return new RunTests(observer, exercise);
+        return new ExceptionTrackingCallable<>(new ExceptionTrackingCallable<>(new RunTests(observer, exercise)));
     }
 
     public Callable<Boolean> sendFeedback(
             ProgressObserver observer, List<FeedbackAnswer> answers, URI feedbackUri) {
         logger.info("Creating new SendFeedback command");
-        return new SendFeedback(observer, answers, feedbackUri);
+        return new ExceptionTrackingCallable<>(new SendFeedback(observer, answers, feedbackUri));
     }
 
     public Callable<Void> sendSpywareEvents(
-            ProgressObserver observer, Course currentCourse, List<LoggableEvent> events) {
+            final ProgressObserver observer, final Course currentCourse, final List<LoggableEvent> events) {
         logger.info("Creating new SenSpywareEvents command");
-        return new SendSpywareEvents(observer, currentCourse, events);
+        return new ExceptionTrackingCallable<>(new SendSpywareEvents(observer, currentCourse, events));
+
     }
 
     public Callable<SubmissionResult> submit(ProgressObserver observer, Exercise exercise) {
         logger.info("Creating new Submit command");
-        return new Submit(observer, exercise);
+        return new ExceptionTrackingCallable<>(new Submit(observer, exercise));
     }
 
     public Callable<GetUpdatableExercises.UpdateResult> getExerciseUpdates(
             ProgressObserver observer, Course course) {
         logger.info("Creating new GetUpdatableExercises command");
-        return new GetUpdatableExercises(observer, course);
+        return new ExceptionTrackingCallable<>(new GetUpdatableExercises(observer, course));
     }
 
     public Callable<Void> markReviewAsRead(ProgressObserver observer, Review review) {
         logger.info("Creating new MarkReviewAsRead command");
-        return new MarkReviewAsRead(observer, review);
+        return new ExceptionTrackingCallable<>(new MarkReviewAsRead(observer, review));
     }
 
     public Callable<List<Review>> getUnreadReviews(ProgressObserver observer, Course course) {
         logger.info("Creating new GetUnreadReviews command");
-        return new GetUnreadReviews(observer, course);
+        return new ExceptionTrackingCallable<>(new GetUnreadReviews(observer, course));
     }
 
     public Callable<TmcServerCommunicationTaskFactory.SubmissionResponse> requestCodeReview(
             ProgressObserver observer, Exercise exercise, String messageForReviewer) {
         logger.info("Creating new RequestCodeReview command");
-        return new RequestCodeReview(observer, exercise, messageForReviewer);
+        return new ExceptionTrackingCallable<>(new RequestCodeReview(observer, exercise, messageForReviewer));
     }
 
     public Callable<Exercise> downloadModelSolution(ProgressObserver observer, Exercise exercise) {
         logger.info("Creating new DownloadModelSolution command");
-        return new DownloadModelSolution(observer, exercise);
+        return new ExceptionTrackingCallable<>(new DownloadModelSolution(observer, exercise));
     }
 
     /**
@@ -156,6 +165,6 @@ public Callable<Exercise> downloadModelSolution(ProgressObserver observer, Exerc
      */
     public Callable<Void> downloadCompletedExercises(ProgressObserver observer) {
         logger.info("Creating new DownloadCompletedExercises command");
-        return new DownloadCompletedExercises(observer);
+        return new ExceptionTrackingCallable<>(new DownloadCompletedExercises(observer));
     }
 }

src/main/java/fi/helsinki/cs/tmc/core/commands/SendDiagnostics.java

@@ -0,0 +1,40 @@
+package fi.helsinki.cs.tmc.core.commands;
+
+import fi.helsinki.cs.tmc.core.communication.TmcBandicootCommunicationTaskFactory;
+import fi.helsinki.cs.tmc.core.domain.ProgressObserver;
+import fi.helsinki.cs.tmc.core.domain.bandicoot.Diagnostics;
+
+import com.google.common.annotations.VisibleForTesting;
+
+/**
+ * Sends general diagnostics about the client.
+ */
+public class SendDiagnostics extends Command<Void> {
+
+    private TmcBandicootCommunicationTaskFactory tmcBandicootCommunicationTaskFactory;
+    private final Diagnostics diagnostics;
+
+    public SendDiagnostics(ProgressObserver observer) {
+        super(observer);
+        this.diagnostics = new Diagnostics();
+        this.tmcBandicootCommunicationTaskFactory = new TmcBandicootCommunicationTaskFactory();
+
+    }
+
+    @VisibleForTesting
+    SendDiagnostics(ProgressObserver observer, TmcBandicootCommunicationTaskFactory factory) {
+        this(observer);
+        this.tmcBandicootCommunicationTaskFactory = factory;
+    }
+
+    /**
+     * Sends diagnostics to tmc-bandicoot.
+     * @return null
+     * @throws Exception ex
+     */
+    @Override
+    public Void call() throws Exception {
+        tmcBandicootCommunicationTaskFactory.sendDiagnostics(diagnostics).call();
+        return null;
+    }
+}

src/main/java/fi/helsinki/cs/tmc/core/communication/TmcBandicootCommunicationTaskFactory.java

@@ -0,0 +1,62 @@
+package fi.helsinki.cs.tmc.core.communication;
+
+import fi.helsinki.cs.tmc.core.communication.http.HttpTasks;
+import fi.helsinki.cs.tmc.core.domain.bandicoot.Crash;
+
+import fi.helsinki.cs.tmc.core.domain.bandicoot.Diagnostics;
+
+import org.apache.commons.lang.math.NumberUtils;
+
+import java.net.URI;
+import java.util.concurrent.Callable;
+
+public class TmcBandicootCommunicationTaskFactory {
+
+    // Diagnostics url must end in '/', or the path resolves with client_infos and crashes won't work
+    private final URI diagnosticsUrl = URI.create("https://tmc-bandicoot.testmycode.io/");
+
+    /**
+     * Sends diagnostics to tmc-bandicoot.
+     * @param diagnostics diagnostics
+     */
+    public Callable<Void> sendDiagnostics(Diagnostics diagnostics) {
+        URI uri = getUrl(diagnostics);
+        final Callable<String> send = new HttpTasks().postJson(uri.resolve("client_infos"), diagnostics);
+
+        return new Callable<Void>() {
+            @Override
+            public Void call() throws Exception {
+                send.call();
+                return null;
+            }
+        };
+    }
+
+    /**
+     * Sends a crash report to tmc-bandicoot.
+     * @param crash a crash
+     */
+    public Callable<Void> sendCrash(Crash crash) {
+        final Callable<String> send = new HttpTasks().postJson(diagnosticsUrl.resolve("crashes"), crash);
+
+        return new Callable<Void>() {
+            @Override
+            public Void call() throws Exception {
+                send.call();
+                return null;
+            }
+        };
+    }
+
+    private URI getUrl(Diagnostics diagnostics) {
+        URI uri = diagnosticsUrl;
+        String[] versionParts = diagnostics.getJavaVersion().split("_");
+        if (versionParts.length == 2) {
+            String version = versionParts[0];
+            if (version.startsWith("1.7") || version.startsWith("1.6") || (version.startsWith("1.8") && NumberUtils.toInt(versionParts[1], 100) < 66)) {
+                uri = URI.create("https://tmc-bandicoot.now.sh/");
+            }
+        }
+        return uri;
+    }
+}

src/main/java/fi/helsinki/cs/tmc/core/communication/http/HttpRequestExecutor.java

@@ -77,7 +77,7 @@ public HttpRequestExecutor setTimeout(int timeoutMs) {
 
     @Override
     public BufferedHttpEntity call()
-            throws IOException, InterruptedException, FailedHttpResponseException {
+        throws IOException, InterruptedException, FailedHttpResponseException {
         CloseableHttpClient httpClient = makeHttpClient();
 
         try {

src/main/java/fi/helsinki/cs/tmc/core/communication/http/HttpTasks.java

@@ -2,18 +2,22 @@
 
 import fi.helsinki.cs.tmc.core.exceptions.FailedHttpResponseException;
 
+import com.google.gson.Gson;
+
 import org.apache.http.NameValuePair;
 import org.apache.http.auth.UsernamePasswordCredentials;
 import org.apache.http.client.entity.UrlEncodedFormEntity;
 import org.apache.http.client.methods.HttpPost;
 import org.apache.http.entity.ByteArrayEntity;
 import org.apache.http.entity.ContentType;
+import org.apache.http.entity.StringEntity;
 import org.apache.http.entity.mime.HttpMultipartMode;
 import org.apache.http.entity.mime.MultipartEntityBuilder;
 import org.apache.http.entity.mime.content.ByteArrayBody;
 import org.apache.http.message.BasicNameValuePair;
 import org.apache.http.util.EntityUtils;
 
+import java.io.Serializable;
 import java.io.UnsupportedEncodingException;
 import java.net.URI;
 import java.util.ArrayList;
@@ -30,6 +34,7 @@
 public class HttpTasks {
     private static final ContentType UTF8_TEXT_CONTENT_TYPE =
             ContentType.create("text/plain", "utf-8");
+    private static final Gson gson = new Gson();
 
     private UsernamePasswordCredentials credentials = null;
 
@@ -46,6 +51,24 @@ private HttpRequestExecutor createExecutor(HttpPost request) {
         return new HttpRequestExecutor(request).setCredentials(credentials);
     }
 
+    /**
+     * Posts json to a url without authentication.
+     */
+    public Callable<String> postJson(final URI uri, final Serializable json) {
+        return new Callable<String>() {
+            @Override
+            public String call() throws Exception {
+                String string = gson.toJson(json);
+                StringEntity content = new StringEntity(string, "UTF-8");
+                HttpPost httpPost = new HttpPost(uri);
+                httpPost.setHeader("content-type", "application/json");
+                httpPost.setEntity(content);
+                HttpRequestExecutor executor = new HttpRequestExecutor(httpPost);
+                return EntityUtils.toString(executor.call());
+            }
+        };
+    }
+
     public Callable<byte[]> getForBinary(URI url) {
         return downloadToBinary(createExecutor(url));
     }

src/main/java/fi/helsinki/cs/tmc/core/configuration/TmcSettings.java

@@ -52,4 +52,8 @@ public interface TmcSettings {
     void setConfigRoot(Path configRoot);
 
     Path getConfigRoot();
+
+    String hostProgramName();
+
+    String hostProgramVersion();
 }

src/main/java/fi/helsinki/cs/tmc/core/domain/bandicoot/Crash.java

@@ -0,0 +1,36 @@
+package fi.helsinki.cs.tmc.core.domain.bandicoot;
+
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.google.gson.annotations.SerializedName;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Crash implements Serializable {
+    private final String name;
+    private final String message;
+    private final String cause;
+    private final List<String> stacktrace;
+    @SerializedName("client_info_attributes")
+    private final Diagnostics diagnostics;
+
+    public Crash(Throwable throwable) {
+        this.name = throwable.toString();
+        this.message = throwable.getMessage();
+        stacktrace = new ArrayList<>();
+        this.diagnostics = new Diagnostics();
+        Optional<String> cause = Optional.fromNullable(throwable.getCause())
+                .transform(new Function<Throwable, String>() {
+                    @Override
+                    public String apply(Throwable throwable) {
+                        return throwable.getMessage();
+                    }
+                });
+        this.cause = cause.orNull();
+        for (StackTraceElement s : throwable.getStackTrace()) {
+            stacktrace.add(s.toString());
+        }
+    }
+}