Merge pull request #608 from optimaster/server-worker-executor

Server worker executor

Author: jknack

jooby-jetty/src/main/java/org/jooby/internal/jetty/JettyServer.java

@@ -22,6 +22,8 @@
 import java.lang.reflect.Method;
 import java.util.Arrays;
 import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -194,6 +196,12 @@ public void stop() throws Exception {
     server.stop();
   }
 
+  @Override
+  public Optional<Executor> executor()
+  {
+    return Optional.ofNullable(server.getThreadPool());
+  }
+
   private void tryOption(final Object source, final Config config, final Method option) {
     Try.run(() -> {
       String optionName = option.getName().replace("set", "");

jooby-jetty/src/test/java/org/jooby/internal/jetty/JettyServerTest.java

@@ -1,7 +1,10 @@
 package org.jooby.internal.jetty;
 
+import static org.easymock.EasyMock.expect;
 import static org.easymock.EasyMock.expectLastCall;
 import static org.easymock.EasyMock.isA;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
 
 import java.util.Map;
 
@@ -109,6 +112,8 @@ public class JettyServerTest {
     server.stop();
 
     unit.registerMock(Server.class, server);
+
+    expect(server.getThreadPool()).andReturn(unit.get(QueuedThreadPool.class)).anyTimes();
   };
 
   private MockUnit.Block httpConf = unit -> {
@@ -194,7 +199,9 @@ public void startStopServer() throws Exception {
           JettyServer server = new JettyServer(unit.get(HttpHandler.class), config,
               unit.get(Provider.class));
 
+          assertNotNull(server.executor());
           server.start();
+          assertTrue(server.executor().isPresent());
           server.join();
           server.stop();
         });

jooby-netty/src/main/java/org/jooby/internal/netty/NettyServer.java

@@ -26,6 +26,8 @@
 import java.lang.reflect.ParameterizedType;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.concurrent.Executor;
 import java.util.concurrent.ThreadFactory;
 import java.util.function.BiConsumer;
 
@@ -152,6 +154,12 @@ public void join() throws InterruptedException {
     ch.closeFuture().sync();
   }
 
+  @Override
+  public Optional<Executor> executor()
+  {
+    return Optional.ofNullable(executor);
+  }
+
   @SuppressWarnings({"rawtypes", "unchecked" })
   private void configure(final Config config, final String path,
       final BiConsumer<ChannelOption<Object>, Object> setter) {

jooby-netty/src/test/java/org/jooby/internal/netty/NettyServerTest.java

@@ -1,5 +1,8 @@
 package org.jooby.internal.netty;
 
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
 import static org.easymock.EasyMock.expect;
 import static org.easymock.EasyMock.isA;
 
@@ -117,7 +120,9 @@ public void defaultServer() throws Exception {
         .run(unit -> {
           NettyServer server = new NettyServer(unit.get(HttpHandler.class), config);
           try {
+            assertNotNull(server.executor());
             server.start();
+            assertTrue(server.executor().isPresent());
             server.join();
           } finally {
             server.stop();

jooby-servlet/src/main/java/org/jooby/servlet/ServletContainer.java

@@ -20,6 +20,9 @@
 
 import org.jooby.spi.Server;
 
+import java.util.Optional;
+import java.util.concurrent.Executor;
+
 /**
  * NOOP server for servlets.
  *
@@ -44,4 +47,9 @@ public void stop() throws Exception {
   public void join() throws InterruptedException {
   }
 
+  @Override
+  public Optional<Executor> executor() {
+    return Optional.empty();
+  }
+
 }

jooby-undertow/src/main/java/org/jooby/internal/undertow/UndertowServer.java

@@ -20,6 +20,8 @@
 
 import java.lang.reflect.Field;
 import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
@@ -206,4 +208,10 @@ public void stop() throws Exception {
     server.stop();
   }
 
+  @Override
+  public Optional<Executor> executor()
+  {
+    return Optional.ofNullable(server.getWorker());
+  }
+
 }

jooby-undertow/src/test/java/org/jooby/internal/undertow/UndertowServerTest.java

@@ -1,5 +1,8 @@
 package org.jooby.internal.undertow;
 
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
 import javax.inject.Provider;
 
 import org.jooby.spi.HttpHandler;
@@ -37,7 +40,9 @@ public void server() throws Exception {
           UndertowServer server = new UndertowServer(unit.get(HttpHandler.class), config,
               unit.get(Provider.class));
           try {
+            assertNotNull(server.executor());
             server.start();
+            assertTrue(server.executor().isPresent());
             server.join();// NOOP
           } finally {
             server.stop();

jooby/src/main/java/org/jooby/Jooby.java

@@ -108,6 +108,7 @@
 import org.jooby.internal.ParameterNameProvider;
 import org.jooby.internal.RequestScope;
 import org.jooby.internal.RouteMetadata;
+import org.jooby.internal.ServerExecutorProvider;
 import org.jooby.internal.ServerLookup;
 import org.jooby.internal.ServerSessionManager;
 import org.jooby.internal.SessionManager;
@@ -2415,6 +2416,24 @@ public Jooby executor(final String name) {
     return this;
   }
 
+  /**
+   * Set a named executor to use from {@link Deferred Deferred API}. Useful for override the
+   * default/global executor.
+   *
+   * Default executor runs each task in the thread that invokes {@link Executor#execute execute},
+   * that's a Jooby worker thread. A worker thread in Jooby can block.
+   *
+   * @param name Name of the executor.
+   * @param provider Provider for the executor.
+   * @return This jooby instance.
+   */
+  private Jooby executor(final String name, final Class<? extends Provider<Executor>> provider) {
+    this.executors.add(binder -> {
+      binder.bind(Key.get(Executor.class, Names.named(name))).toProvider(provider).in(Singleton.class);
+    });
+    return this;
+  }
+
   /**
    * If the application fails to start all the services are shutdown. Also, the exception is logged
    * and usually the application is going to exit.
@@ -2565,6 +2584,7 @@ private Injector bootstrap(final Config args,
       executor(MoreExecutors.directExecutor());
     }
     executor("direct", MoreExecutors.directExecutor());
+    executor("server", ServerExecutorProvider.class);
 
     /** Some basic xss functions. */
     xss(finalEnv);

jooby/src/main/java/org/jooby/internal/ServerExecutorProvider.java

@@ -0,0 +1,55 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.jooby.internal;
+
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.inject.Inject;
+import com.google.inject.Provider;
+import org.jooby.spi.Server;
+
+import java.util.concurrent.Executor;
+
+import static java.util.Objects.requireNonNull;
+
+public class ServerExecutorProvider implements Provider<Executor>
+{
+
+  private Executor executor;
+
+  @Inject
+  public ServerExecutorProvider(final ServerHolder serverHolder) {
+    requireNonNull(serverHolder, "Server holder is required.");
+
+    executor = (serverHolder.server != null) ?
+               serverHolder.server.executor().orElse(MoreExecutors.directExecutor()) :
+               MoreExecutors.directExecutor();
+  }
+
+  @Override
+  public Executor get() {
+    return executor;
+  }
+
+  static class ServerHolder {
+
+    @Inject(optional = true) Server server = null;
+
+  }
+
+}

jooby/src/main/java/org/jooby/spi/Server.java

@@ -18,6 +18,8 @@
  */
 package org.jooby.spi;
 
+import java.util.Optional;
+import java.util.concurrent.Executor;
 
 /**
  * A HTTP web server.
@@ -48,4 +50,11 @@ public interface Server {
    */
   void join() throws InterruptedException;
 
+  /**
+   * Obtain the executor for worker threads.
+   *
+   * @return The executor for worker threads.
+   */
+  Optional<Executor> executor();
+
 }