Idle timeout between servers and a few other server options

Author: jknack

jooby-jetty/src/main/resources/org/jooby/spi/server.conf

@@ -41,10 +41,10 @@ jetty {
       # The max idle time is applied:
       #   When waiting for a new message to be received on a connection
       #   When waiting for a new message to be sent on a connection
-      
+
       # This value is interpreted as the maximum time between some progress being made on the connection.
       # So if a single byte is read or written, then the timeout is reset.
-      IdleTimeout = 30000
+      IdleTimeout = ${server.http.IdleTimeout}
     }
   }
 

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

@@ -27,6 +27,7 @@
 import io.netty.handler.codec.http.HttpHeaders;
 import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.handler.codec.http.websocketx.WebSocketFrame;
+import io.netty.handler.timeout.IdleStateEvent;
 import io.netty.util.Attribute;
 
 import org.jooby.spi.HttpHandler;
@@ -42,11 +43,18 @@ public class NettyHandler extends SimpleChannelInboundHandler<Object> {
 
   private HttpHandler handler;
 
-  private Config config;
+  private String tmpdir;
+
+  private int wsMaxMessageSize;
 
   public NettyHandler(final HttpHandler handler, final Config config) {
     this.handler = requireNonNull(handler, "Application handler is required.");
-    this.config = requireNonNull(config, "Application config is required.");
+    this.tmpdir = config.getString("application.tmpdir");
+    this.wsMaxMessageSize = Math
+        .max(
+            config.getBytes("server.ws.MaxTextMessageSize").intValue(),
+            config.getBytes("server.ws.MaxBinaryMessageSize").intValue()
+        );
   }
 
   @Override
@@ -65,7 +73,7 @@ public void channelRead0(final ChannelHandlerContext ctx, final Object msg) {
       boolean keepAlive = HttpHeaders.isKeepAlive(req);
 
       try {
-        NettyRequest nreq = new NettyRequest(ctx, req, config.getString("application.tmpdir"));
+        NettyRequest nreq = new NettyRequest(ctx, req, tmpdir, wsMaxMessageSize);
         handler.handle(nreq, new NettyResponse(ctx, nreq, keepAlive));
       } catch (Throwable ex) {
         exceptionCaught(ctx, ex);
@@ -90,4 +98,16 @@ public void exceptionCaught(final ChannelHandlerContext ctx, final Throwable cau
     }
   }
 
+  @Override
+  public void userEventTriggered(final ChannelHandlerContext ctx, final Object evt)
+      throws Exception {
+    // Idle timeout
+    if (evt instanceof IdleStateEvent) {
+      log.debug("idle timeout: {}", ctx);
+      ctx.close();
+    } else {
+      super.userEventTriggered(ctx, evt);
+    }
+  }
+
 }

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

@@ -22,8 +22,11 @@
 import io.netty.channel.socket.SocketChannel;
 import io.netty.handler.codec.http.HttpObjectAggregator;
 import io.netty.handler.codec.http.HttpServerCodec;
+import io.netty.handler.timeout.IdleStateHandler;
 import io.netty.util.concurrent.EventExecutorGroup;
 
+import java.util.concurrent.TimeUnit;
+
 import org.jooby.spi.HttpHandler;
 
 import com.typesafe.config.Config;
@@ -44,6 +47,8 @@ public class NettyInitializer extends ChannelInitializer<SocketChannel> {
 
   private int maxContentLength;
 
+  private long idleTimeOut;
+
   public NettyInitializer(final EventExecutorGroup executor, final HttpHandler handler,
       final Config config) {
     this.executor = executor;
@@ -54,13 +59,15 @@ public NettyInitializer(final EventExecutorGroup executor, final HttpHandler han
     maxHeaderSize = config.getBytes("netty.http.MaxHeaderSize").intValue();
     maxChunkSize = config.getBytes("netty.http.MaxChunkSize").intValue();
     maxContentLength = config.getBytes("netty.http.MaxContentLength").intValue();
+    idleTimeOut = config.getDuration("netty.http.IdleTimeout", TimeUnit.MILLISECONDS);
   }
 
   @Override
   protected void initChannel(final SocketChannel ch) throws Exception {
     ch.pipeline()
         .addLast(new HttpServerCodec(maxInitialLineLength, maxHeaderSize, maxChunkSize))
         .addLast(new HttpObjectAggregator(maxContentLength))
+        .addLast(new IdleStateHandler(0, 0, idleTimeOut, TimeUnit.MILLISECONDS))
         .addLast(executor, new NettyHandler(handler, config));
   }
 

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

@@ -71,13 +71,16 @@ public class NettyRequest implements NativeRequest {
 
   private ChannelHandlerContext ctx;
 
-  public NettyRequest(final ChannelHandlerContext ctx, final HttpRequest req, final String tmpdir)
-      throws IOException {
+  private int wsMaxMessageSize;
+
+  public NettyRequest(final ChannelHandlerContext ctx, final HttpRequest req, final String tmpdir,
+      final int wsMaxMessageSize) throws IOException {
     this.ctx = ctx;
     this.req = req;
     this.tmpdir = tmpdir;
     this.query = new QueryStringDecoder(req.getUri());
     this.path = URLDecoder.decode(query.path(), "UTF-8");
+    this.wsMaxMessageSize = wsMaxMessageSize;
   }
 
   @Override
@@ -177,7 +180,7 @@ public <T> T upgrade(final Class<T> type) throws Exception {
     String webSocketURL = protocol + "://" + req.headers().get(HttpHeaders.Names.HOST) + path;
 
     WebSocketServerHandshakerFactory wsFactory =
-        new WebSocketServerHandshakerFactory(webSocketURL, null, true);
+        new WebSocketServerHandshakerFactory(webSocketURL, null, true, wsMaxMessageSize);
     WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(req);
     NettyWebSocket result = new NettyWebSocket(ctx, handshaker, (ws) -> {
       handshaker.handshake(ctx.channel(), (FullHttpRequest) req)

jooby-netty/src/main/resources/org/jooby/spi/server.conf

@@ -10,6 +10,8 @@ netty {
     MaxChunkSize = 8k
 
     MaxContentLength = ${server.http.MaxRequestSize}
+
+    IdleTimeout = ${server.http.IdleTimeout}
   }
 
   threads {