ratpack.server.internal.NettyHandlerAdapter Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of ratpack-core Show documentation
null
There is a newer version: 2.0.0-rc-1
/*
 * Copyright 2013 the original author or authors.
 *
 * Licensed 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 ratpack.server.internal;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.handler.codec.http.*;
import io.netty.handler.ssl.SslHandler;
import io.netty.handler.ssl.SslHandshakeCompletionEvent;
import io.netty.handler.timeout.IdleStateEvent;
import io.netty.util.Attribute;
import io.netty.util.AttributeKey;
import io.netty.util.CharsetUtil;
import io.netty.util.ReferenceCountUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ratpack.exec.ExecController;
import ratpack.exec.Execution;
import ratpack.func.Action;
import ratpack.handling.Handler;
import ratpack.handling.Handlers;
import ratpack.handling.internal.DefaultContext;
import ratpack.handling.internal.DescribingHandler;
import ratpack.handling.internal.DescribingHandlers;
import ratpack.http.Headers;
import ratpack.http.MutableHeaders;
import ratpack.http.Response;
import ratpack.http.internal.*;
import ratpack.registry.Registry;
import ratpack.render.internal.DefaultRenderController;
import ratpack.server.ServerConfig;

import javax.annotation.Nullable;
import javax.net.ssl.SSLEngine;
import javax.net.ssl.SSLPeerUnverifiedException;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.CharBuffer;
import java.nio.channels.ClosedChannelException;
import java.time.Clock;
import java.time.Duration;
import java.util.ArrayDeque;
import java.util.Locale;
import java.util.Queue;
import java.util.concurrent.atomic.AtomicBoolean;

@ChannelHandler.Sharable
public class NettyHandlerAdapter extends ChannelInboundHandlerAdapter {

  private final static Logger LOGGER = LoggerFactory.getLogger(NettyHandlerAdapter.class);

  private final Handler handler;

  private final DefaultContext.ApplicationConstants applicationConstants;

  private final Registry serverRegistry;
  private final boolean development;
  private final Clock clock;
  private final Duration idleTimeout;
  private final ServerConfig serverConfig;

  public NettyHandlerAdapter(Registry serverRegistry, Handler handler) {
    this.serverConfig = serverRegistry.get(ServerConfig.class);
    this.handler = handler;
    this.serverRegistry = serverRegistry;
    this.applicationConstants = new DefaultContext.ApplicationConstants(
      this.serverRegistry,
      new DefaultRenderController(),
      serverRegistry.get(ExecController.class),
      Handlers.notFound()
    );
    this.development = serverConfig.isDevelopment();
    this.clock = serverRegistry.get(Clock.class);
    this.idleTimeout = serverConfig.getIdleTimeout();
  }

  @Override
  public void handlerAdded(ChannelHandlerContext ctx) {
    Attribute attr = ctx.channel().attr(ChannelState.KEY);
    if (attr.get() == null) {
      ChannelState state = new ChannelState(new ConnectionIdleTimeout(ctx.pipeline(), idleTimeout));
      attr.set(state);
      ctx.channel().closeFuture().addListener(future -> {
        if (state.responseTransmitter != null) {
          state.responseTransmitter.onConnectionClosed();
        }

        if (state.requestBody != null) {
          state.requestBody.onClose();
        }
      });
    }
  }

  @Override
  public void channelActive(ChannelHandlerContext ctx) throws Exception {
    ctx.read();
    super.channelActive(ctx);
  }

  @Override
  public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    ChannelState state = state(ctx);
    if (state.messageQueue == null) {
      handleMessage(ctx, msg, state);
    } else {
      // There are no bounds on the queue at this level.
      // We are relying on the upstream TCP buffers to provide the bounding.
      state.messageQueue.add(msg);
    }
  }

  private void handleMessage(ChannelHandlerContext ctx, Object msg, ChannelState state) throws Exception {
    if (msg instanceof HttpRequest) {
      handleRequest(ctx, (HttpRequest) msg, state);
    } else if (msg instanceof HttpContent) {
      handleContent(ctx, (HttpContent) msg, state);
    } else {
      handleOther(ctx, msg, state);
    }
  }

  private void handleRequest(ChannelHandlerContext ctx, HttpRequest request, ChannelState state) {
    state.requestedNextRequest = false;
    if (state.responseTransmitter == null) {
      newRequest(ctx, request, state);
    } else {
      state.messageQueue = new ArrayDeque<>();
      state.messageQueue.add(request);
    }
  }

  private static void handleContent(ChannelHandlerContext ctx, HttpContent httpContent, ChannelState state) {
    if (state.requestBody == null) {
      httpContent.release();
    } else {
      state.requestBody.add(httpContent.touch());
    }

    // Read for the next request proactively so that we detect if the client closes the connection.
    if (httpContent instanceof LastHttpContent) {
      state.requestedNextRequest = true;
      ctx.channel().read();
    }
  }

  private void handleOther(ChannelHandlerContext ctx, Object msg, ChannelState state) throws Exception {
    Action