Added Service.awaitStop(). (#730)

* Added Service.stopAndWait().

* Doc comments, small test improvements, log when interrupted.

* Renamed stopAndWait() -> awaitStop(), refactored.

Changed it to be more like init() and awaitInitialization().

* Expose `awaitStop()` via static method in `Spark`.

src/main/java/spark/Service.java

@@ -76,7 +76,8 @@ public final class Service extends Routable {
     protected Deque<String> pathDeque = new ArrayDeque<>();
     protected Routes routes;
 
-    private CountDownLatch latch = new CountDownLatch(1);
+    private CountDownLatch initLatch = new CountDownLatch(1);
+    private CountDownLatch stopLatch = new CountDownLatch(0);
 
     private Object embeddedServerIdentifier = null;
 
@@ -440,7 +441,7 @@ public void awaitInitialization() {
         }
 
         try {
-            latch.await();
+            initLatch.await();
         } catch (InterruptedException e) {
             LOG.info("Interrupted by another thread");
             Thread.currentThread().interrupt();
@@ -458,20 +459,43 @@ private boolean hasMultipleHandlers() {
 
 
     /**
-     * Stops the Spark server and clears all routes
+     * Stops the Spark server and clears all routes.
      */
     public synchronized void stop() {
-        new Thread(() -> {
+    	if (!initialized) {
+    		return;
+    	}
+        initiateStop();
+    }
+
+    /**
+     * Waits for the Spark server to stop.
+     * <b>Warning:</b> this method should not be called from a request handler.
+     */
+    public void awaitStop() {
+        try {
+            stopLatch.await();
+        } catch (InterruptedException e) {
+            LOG.warn("Interrupted by another thread");
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    private void initiateStop() {
+    	stopLatch = new CountDownLatch(1);
+        Thread stopThread = new Thread(() -> {
             if (server != null) {
                 server.extinguish();
-                latch = new CountDownLatch(1);
+                initLatch = new CountDownLatch(1);
             }
 
             routes.clear();
             exceptionMapper.clear();
             staticFilesConfiguration.clear();
             initialized = false;
-        }).start();
+            stopLatch.countDown();
+        });
+        stopThread.start();
     }
 
     /**
@@ -557,7 +581,7 @@ public synchronized void init() {
                     initExceptionHandler.accept(e);
                   }
                     try {
-                        latch.countDown();
+                        initLatch.countDown();
                         server.join();
                     } catch (InterruptedException e) {
                         LOG.error("server interrupted", e);

src/main/java/spark/Spark.java

@@ -1173,6 +1173,14 @@ public static void awaitInitialization() {
     public static void stop() {
         getInstance().stop();
     }
+
+    /**
+     * Waits for the Spark server to be stopped.
+     * If it's already stopped, will return immediately.
+     */
+    public static void awaitStop() {
+    	getInstance().awaitStop();
+    }
 
     ////////////////
     // Websockets //

src/test/java/spark/ServiceTest.java

@@ -7,11 +7,15 @@
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
+import org.mockito.Mockito;
 import org.powermock.reflect.Whitebox;
 
+import spark.embeddedserver.EmbeddedServer;
+import spark.route.Routes;
 import spark.ssl.SslStores;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static spark.Service.ignite;
 
@@ -239,6 +243,40 @@ public void testWebSocket_whenHandlerNull_thenThrowNullPointerException() {
         service.webSocket("/", null);
     }
 
+    @Test(timeout = 300)
+    public void stopExtinguishesServer() {
+        Service service = Service.ignite();
+        Routes routes = Mockito.mock(Routes.class);
+        EmbeddedServer server = Mockito.mock(EmbeddedServer.class);
+        service.routes = routes;
+        service.server = server;
+        service.initialized = true;
+        service.stop();
+        try {
+        	// yes, this is ugly and forces to set a test timeout as a precaution :(
+            while (service.initialized) {
+            	Thread.sleep(20);
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+        Mockito.verify(server).extinguish();
+    }
+
+    @Test
+    public void awaitStopBlocksUntilExtinguished() {
+        Service service = Service.ignite();
+        Routes routes = Mockito.mock(Routes.class);
+        EmbeddedServer server = Mockito.mock(EmbeddedServer.class);
+        service.routes = routes;
+        service.server = server;
+        service.initialized = true;
+        service.stop();
+        service.awaitStop();
+        Mockito.verify(server).extinguish();
+        assertFalse(service.initialized);
+    }
+
     @WebSocket
     protected static class DummyWebSocketListener {
     }