Add HTTP publishing and image source operations (#551)

* HTTP publishing now works

* Implemented an image source for images POSTed to the HTTP server.

Images must be posted to /GRIP/upload/image -- there could be a need to have the path be user-defined
Images are treated as 8-bit 3-channel color images.

* Adds support for setting pipelines via HTTP POST operations

* Changed pipeline upload to upload the contents of a GRIP project rather than the path to a save file

* Changed GripServer to return a 500 error on a POST only if an exception was thrown while handling the data.

* Removes need to specify project file at startup

* 500 error if no data is received from a POST

* Pipeline no longer runs during deserialization

GripServer returns a 423 error if a data request is sent while the
pipeline is running

* Return 503 Service Unavailable when trying to get data when pipeline is running

Use library-defined HTTP codes instead of redefining them
404 error when going to a URI such as /GRIP/data/foo or /GRIP/data* (now it has to be on a path that has a handler specifically assigned to it)
Update tests to stop codacy bot from complaining so much


HTTP sources can only supply images POSTed to URLs under '/GRIP/upload/image', e.g. '/GRIP/upload/image/foo'

Author: SamCarlberg

build.gradle

@@ -202,6 +202,11 @@ project(":core") {
         compile group: 'org.apache.commons', name: 'commons-lang3', version: '3.4'
         compile group: 'com.google.guava', name: 'guava', version: '19.0'
         compile group: 'com.google.auto.value', name: 'auto-value', version: '1.1'
+        compile group: 'com.google.code.gson', name: 'gson', version: '2.6.2'
+        compile group: 'org.eclipse.jetty', name:'jetty-server', version:'9.3.8.v20160314'
+        testCompile group: 'org.apache.httpcomponents', name: 'httpclient', version: '4.5.2'
+        testCompile group: 'org.apache.httpcomponents', name: 'httpcore', version: '4.2.2'
+        testCompile group: 'org.apache.httpcomponents', name: 'httpmime', version: '4.5.2'
         // We use the no_aop version of Guice because the aop isn't avaiable in arm java
         // http://stackoverflow.com/a/15235190/3708426
         // https://github.com/google/guice/wiki/OptionalAOP

core/src/main/java/edu/wpi/grip/core/GripCoreModule.java

@@ -8,6 +8,7 @@
 import edu.wpi.grip.core.sockets.OutputSocket;
 import edu.wpi.grip.core.sockets.OutputSocketImpl;
 import edu.wpi.grip.core.sources.CameraSource;
+import edu.wpi.grip.core.sources.HttpSource;
 import edu.wpi.grip.core.sources.ImageFileSource;
 import edu.wpi.grip.core.sources.MultiImageFileSource;
 import edu.wpi.grip.core.util.ExceptionWitness;
@@ -137,6 +138,9 @@ public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
     install(new FactoryModuleBuilder()
         .implement(MultiImageFileSource.class, MultiImageFileSource.class)
         .build(MultiImageFileSource.Factory.class));
+    install(new FactoryModuleBuilder()
+        .implement(HttpSource.class, HttpSource.class)
+        .build(HttpSource.Factory.class));
 
     install(new FactoryModuleBuilder().build(ExceptionWitness.Factory.class));
   }

core/src/main/java/edu/wpi/grip/core/Main.java

@@ -2,6 +2,8 @@
 
 import edu.wpi.grip.core.events.ExceptionClearedEvent;
 import edu.wpi.grip.core.events.ExceptionEvent;
+import edu.wpi.grip.core.http.GripServer;
+import edu.wpi.grip.core.http.HttpPipelineSwitcher;
 import edu.wpi.grip.core.operations.CVOperations;
 import edu.wpi.grip.core.operations.Operations;
 import edu.wpi.grip.core.operations.network.GripNetworkModule;
@@ -12,6 +14,7 @@
 import com.google.common.eventbus.Subscribe;
 import com.google.inject.Guice;
 import com.google.inject.Injector;
+import com.google.inject.util.Modules;
 
 import java.io.File;
 import java.io.IOException;
@@ -37,30 +40,35 @@ public class Main {
   private CVOperations cvOperations;
   @Inject
   private Logger logger;
+  @Inject
+  private GripServer gripServer;
+  @Inject
+  private HttpPipelineSwitcher pipelineSwitcher;
 
   @SuppressWarnings({"PMD.SystemPrintln", "JavadocMethod"})
   public static void main(String[] args) throws IOException, InterruptedException {
-    final Injector injector = Guice.createInjector(new GripCoreModule(), new GripNetworkModule(),
-        new GripSourcesHardwareModule());
+    final Injector injector = Guice.createInjector(Modules.override(
+        new GripCoreModule(), new GripSourcesHardwareModule()).with(new GripNetworkModule()));
     injector.getInstance(Main.class).start(args);
   }
 
   @SuppressWarnings({"PMD.SystemPrintln", "JavadocMethod"})
   public void start(String[] args) throws IOException, InterruptedException {
-    if (args.length != 1) {
-      System.err.println("Usage: GRIP.jar project.grip");
-      return;
-    } else {
+    String projectPath = null;
+    if (args.length == 1) {
       logger.log(Level.INFO, "Loading file " + args[0]);
+      projectPath = args[0];
     }
 
     operations.addOperations();
     cvOperations.addOperations();
-
-    final String projectPath = args[0];
+    gripServer.addHandler(pipelineSwitcher);
+    gripServer.start();
 
     // Open a project from a .grip file specified on the command line
-    project.open(new File(projectPath));
+    if (projectPath != null) {
+      project.open(new File(projectPath));
+    }
 
     pipelineRunner.startAsync();
 
@@ -88,4 +96,4 @@ public final void onExceptionClearedEvent(ExceptionClearedEvent event) {
         + "Event");
   }
 
-}
+}

core/src/main/java/edu/wpi/grip/core/PipelineRunner.java

@@ -3,6 +3,8 @@
 
 import edu.wpi.grip.core.events.RenderEvent;
 import edu.wpi.grip.core.events.RunPipelineEvent;
+import edu.wpi.grip.core.events.RunStartedEvent;
+import edu.wpi.grip.core.events.RunStoppedEvent;
 import edu.wpi.grip.core.events.StopPipelineEvent;
 import edu.wpi.grip.core.util.SinglePermitSemaphore;
 import edu.wpi.grip.core.util.service.AutoRestartingService;
@@ -28,6 +30,8 @@
 import javax.annotation.Nullable;
 import javax.inject.Inject;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+
 /**
  * Runs the pipeline in a separate thread. The runner listens for {@link RunPipelineEvent
  * RunPipelineEvents} and releases the pipeline thread to update the sources and run the steps.
@@ -68,6 +72,7 @@ protected void runOneIteration() throws InterruptedException {
             }
 
             pipelineFlag.acquire();
+            eventBus.post(new RunStartedEvent());
 
             if (!super.isRunning()) {
               return;
@@ -77,6 +82,7 @@ protected void runOneIteration() throws InterruptedException {
             if (super.isRunning()) {
               eventBus.post(new RenderEvent());
             }
+            eventBus.post(new RunStoppedEvent());
           }
 
           @Override
@@ -196,6 +202,7 @@ private void runPipeline(Supplier<Boolean> isRunning) {
   @Subscribe
   @AllowConcurrentEvents
   public void onRunPipeline(RunPipelineEvent event) {
+    checkNotNull(event);
     if (event.pipelineShouldRun()) {
       pipelineFlag.release();
     }

core/src/main/java/edu/wpi/grip/core/Source.java

@@ -2,6 +2,7 @@
 
 import edu.wpi.grip.core.sockets.OutputSocket;
 import edu.wpi.grip.core.sources.CameraSource;
+import edu.wpi.grip.core.sources.HttpSource;
 import edu.wpi.grip.core.sources.ImageFileSource;
 import edu.wpi.grip.core.sources.MultiImageFileSource;
 import edu.wpi.grip.core.util.ExceptionWitness;
@@ -108,6 +109,8 @@ public static class SourceFactoryImpl implements SourceFactory {
     ImageFileSource.Factory imageFactory;
     @Inject
     MultiImageFileSource.Factory multiImageFactory;
+    @Inject
+    HttpSource.Factory httpFactory;
 
     @Override
     public Source create(Class<?> type, Properties properties) throws IOException {
@@ -117,6 +120,8 @@ public Source create(Class<?> type, Properties properties) throws IOException {
         return imageFactory.create(properties);
       } else if (type.isAssignableFrom(MultiImageFileSource.class)) {
         return multiImageFactory.create(properties);
+      } else if (type.isAssignableFrom(HttpSource.class)) {
+        return httpFactory.create(properties);
       } else {
         throw new IllegalArgumentException(type + " was not a valid type");
       }

core/src/main/java/edu/wpi/grip/core/events/RunStartedEvent.java

@@ -0,0 +1,8 @@
+package edu.wpi.grip.core.events;
+
+/**
+ * An event fired when the pipeline starts running. This is guaranteed to be followed by a
+ * corresponding {@link RunStoppedEvent}.
+ */
+public class RunStartedEvent {
+}

core/src/main/java/edu/wpi/grip/core/events/RunStoppedEvent.java

@@ -0,0 +1,11 @@
+package edu.wpi.grip.core.events;
+
+/**
+ * An event fired when the pipeline stops running. This is guaranteed to follow a corresponding
+ * {@link RunStartedEvent}.
+ *
+ * <p>This is different from {@link RenderEvent} in that it will <i>always</i> be fired when the
+ * pipeline runs.
+ */
+public class RunStoppedEvent {
+}

core/src/main/java/edu/wpi/grip/core/exception/GripException.java

@@ -0,0 +1,19 @@
+
+package edu.wpi.grip.core.exception;
+
+/**
+ * An exception thrown when something goes wrong with an internal GRIP
+ * operation. This class is {@code abstract} to encourage making subclasses
+ * for specific cases.
+ */
+public abstract class GripException extends RuntimeException {
+
+  public GripException(String message) {
+    super(message);
+  }
+
+  public GripException(String message, Throwable cause) {
+    super(message, cause);
+  }
+
+}

core/src/main/java/edu/wpi/grip/core/exception/GripServerException.java

@@ -0,0 +1,16 @@
+package edu.wpi.grip.core.exception;
+
+/**
+ * An exception thrown when something goes wrong in the
+ * {@link edu.wpi.grip.core.http.GripServer GripServer}.
+ */
+public class GripServerException extends GripException {
+
+  public GripServerException(String message) {
+    super(message);
+  }
+
+  public GripServerException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

core/src/main/java/edu/wpi/grip/core/http/ContextStore.java

@@ -0,0 +1,58 @@
+package edu.wpi.grip.core.http;
+
+import com.google.inject.Singleton;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Keeps a record of contexts claimed by HTTP request handlers.
+ */
+@Singleton
+public class ContextStore {
+
+  private final Set<String> store = new HashSet<>();
+
+  /**
+   * Records the given context.
+   *
+   * @param context the context to record. This cannot be null.
+   * @throws IllegalArgumentException if the given context has already been claimed
+   */
+  public void record(@Nonnull String context) throws IllegalArgumentException {
+    checkNotNull(context);
+    if (!store.add(context)) {
+      throw new IllegalArgumentException("Context is already claimed: " + context);
+    }
+  }
+
+  /**
+   * Erases the given context from this store, if it's present. If {@code context} is {@code null},
+   * this will do nothing and return {@code false}.
+   *
+   * @param context the context to erase
+   * @return true if the context was erased, false if it wasn't erased
+   *         or if it wasn't present to begin with.
+   */
+  public boolean erase(@Nullable String context) {
+    return store.remove(context);
+  }
+
+  /**
+   * Checks if the given context has been recorded in this store.
+   * If {@code context} is {@code null}, this will return {@code false}.
+   *
+   * @param context the context to check
+   * @return true if the given context has been recorded in this store
+   */
+  public boolean contains(@Nullable String context) {
+    return store.contains(context);
+  }
+
+
+}