* 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,
 * See the License for the specific language governing permissions and
 * limitations under the License.
package org.apache.hadoop.http;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.conf.Configuration;
import org.jboss.netty.bootstrap.ServerBootstrap;
import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelException;
import org.jboss.netty.channel.ChannelFactory;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.group.ChannelGroup;
import org.jboss.netty.channel.group.DefaultChannelGroup;
import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;
import com.google.common.util.concurrent.ThreadFactoryBuilder;

 * Create a Netty server to only answer map output http requests. HttpServer is
 * used to handle all other requests.
public class NettyMapOutputHttpServer {
  /** Maximum thread pool size key */
  public static final String MAXIMUM_THREAD_POOL_SIZE =
  /** Default maximum thread pool size (same as jetty) */
  public static final int DEFAULT_MAXIMUM_THREAD_POOL_SIZE = 254;
  /** Class logger */
  private static final Log LOG =

  private ChannelFactory channelFactory;
  /** Port that this server runs on */
  private int port;
  /** Accepted channels */
  private final ChannelGroup accepted = new DefaultChannelGroup();
  /** Maximum bind attempts */
  private final int DEFAULT_BIND_ATTEMPT_MAX = 50;
  /** Worker thread pool (if implemented as a ThreadPoolExecutor) */
  private ThreadPoolExecutor workerThreadPool = null;

   * Create a status server on the given port.
   * The jsp scripts are taken from src/webapps/<name>.
   * @param name The name of the server
   * @param startingPort The port to use on the server (or start
   *        at if binding fails).  If 0, use an let the server pick the port.
  public NettyMapOutputHttpServer(int startingPort) throws IOException {
    this.port = startingPort;

  public synchronized void init(Configuration conf) {
      ThreadFactory bossFactory = new ThreadFactoryBuilder()
        .setNameFormat("ShuffleHandler Netty Boss #%d")
    ThreadFactory workerFactory = new ThreadFactoryBuilder()
        .setNameFormat("ShuffleHandler Netty Worker #%d")

    int maximumPoolSize = conf.getInt(MAXIMUM_THREAD_POOL_SIZE,
    try {
      workerThreadPool =
        (ThreadPoolExecutor) Executors.newCachedThreadPool(workerFactory);
    } catch (ClassCastException e) {
      LOG.warn("Netty worker thread pool is not of type ThreadPoolExecutor", e);
    LOG.info("Netty starting up with a maximum of " + maximumPoolSize +
        " worker threads");
    channelFactory = new NioServerSocketChannelFactory(
        workerThreadPool, maximumPoolSize);

  public synchronized int start(ChannelPipelineFactory pipelineFactory) {
    ServerBootstrap bootstrap = new ServerBootstrap(channelFactory);
    // Try to bind to a port.  If the port is 0, netty will select a port.
    int bindAttempt = 0;
    while (bindAttempt < DEFAULT_BIND_ATTEMPT_MAX) {
      try {
        InetSocketAddress address = new InetSocketAddress(port);
        Channel ch = bootstrap.bind(address);
        port = ((InetSocketAddress) ch.getLocalAddress()).getPort();
      } catch (ChannelException e) {
        LOG.warn("start: Likely failed to bind on attempt " +
                 bindAttempt + " to port " + port, e);
        // Only increment the port number when set by the user
        if (port != 0) {

    LOG.info(this.getClass() + " is listening on port " + port);
    return port;

  public synchronized void stop() {
    accepted.close().awaitUninterruptibly(10, TimeUnit.SECONDS);
    ServerBootstrap bootstrap = new ServerBootstrap(channelFactory);

   * Get the worker thread pool for metrics.
   * @return Worker thread pool or null if the thread pool is not a
   *         ThreadPoolExcecutor.
  public ThreadPoolExecutor getWorkerThreadPool() {
    return workerThreadPool;