io.airlift.http.server.WebServerModule Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of webserver Show documentation
There is a newer version: 0.0.6
package io.airlift.http.server;

import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.Map;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.eclipse.jetty.servlet.FilterHolder;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;

import com.google.inject.AbstractModule;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Key;
import com.google.inject.Provider;

import io.airlift.http.server.model.FilterDefinition;
import io.airlift.http.server.model.ServletDefinition;
import io.airlift.http.server.model.WebServerDefinition;
import io.airlift.http.server.model.WebServerDefinitionBuilder;

public class WebServerModule extends AbstractModule {

  private WebServerDefinitionBuilder webServerDefinitionBuilder;

  public WebServerModule() {
    webServerDefinitionBuilder = new WebServerDefinitionBuilder();
  }

  @Override
  protected void configure() {
    bind(WebServer.class).toProvider(WebServerProvider.class);
    bind(WebServerDefinitionBuilder.class).toInstance(webServerDefinitionBuilder);
    configureWebServer();
  }

  protected void configureWebServer() {}

  public WebServerModule port(int port) {
    webServerDefinitionBuilder.port(port);
    return this;
  }

  public WebServerModule filter(String pattern) {
    webServerDefinitionBuilder.filter(pattern);
    return this;
  }

  public WebServerModule through(Class filterClass) {
    webServerDefinitionBuilder.through(filterClass);
    return this;
  }

  public WebServerModule serve(String pattern) {
    webServerDefinitionBuilder.serve(pattern);
    return this;
  }

  public WebServerModule with(Class servletClass) {
    webServerDefinitionBuilder.with(servletClass);
    return this;
  }

  public WebServerModule with(Class servletClass, Map parameters) {
    webServerDefinitionBuilder.with(servletClass, parameters);
    return this;
  }

  public WebServerModule with(File war) {
    webServerDefinitionBuilder.with(war);
    return this;
  }  
  
  public WebServerModule at(String path) {
    webServerDefinitionBuilder.at(path);
    return this;
  }

  public WebServerModule resource(String resource) {
    webServerDefinitionBuilder.resource(resource);
    return this;
  }

  public WebServerModule resource(String resource, List welcomeFiles) {
    webServerDefinitionBuilder.resource(resource, welcomeFiles);
    return this;
  }

  static class WebServerProvider implements Provider {

    @Inject
    Injector injector;
    
    @Inject
    WebServerDefinitionBuilder webServerDefinitionBuilder;
        
    @Override
    public WebServer get() {
      return new JettyWebServer(webServerDefinitionBuilder.build()) {
        @Override
        protected void construct(WebServerDefinition webServerDefinition, ServletContextHandler applicationContext) {

          for (FilterDefinition filterDefinition : webServerDefinition.getFilterDefintions()) {
            applicationContext.addFilter(new FilterHolder(forFilter(injector.getProvider(Key.get(filterDefinition.getFilterClass())))), filterDefinition.getPattern(), null);
          }

          for (ServletDefinition servletDefinition : webServerDefinition.getServletDefinitions()) {
            ServletHolder servletHolder = new ServletHolder(forServlet(injector.getProvider(servletDefinition.getServletClass())));
            servletHolder.setInitParameters(servletDefinition.getParameters());
            applicationContext.addServlet(servletHolder, servletDefinition.getPattern());
          }
        };
      };
    }
  }
  
  public static ManagedFilter forFilter(Provider provider) {
    return new ManagedFilter(provider);
  }

  public static ManagedServlet forServlet(Provider provider) {
    return new ManagedServlet(provider);
  }

  public static ManagedServletContextListener forListener(Provider provider) {
    return new ManagedServletContextListener(provider);
  }

  private static class ManagedServletContextListener implements ServletContextListener {
    private final Provider target;

    ManagedServletContextListener(Provider target) {
      this.target = target;
    }

    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
      target.get().contextInitialized(servletContextEvent);
    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {
      target.get().contextDestroyed(servletContextEvent);
    }
  }

  private static class ManagedFilter implements Filter {
    private final Provider target;

    public ManagedFilter(Provider target) {
      this.target = target;
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
      target.get().init(filterConfig);
    }

    @Override
    public void doFilter(ServletRequest servletRequest,
      ServletResponse servletResponse,
      FilterChain filterChain) throws IOException, ServletException {
      target.get().doFilter(servletRequest, servletResponse, filterChain);
    }

    @Override
    public void destroy() {
      target.get().destroy();
    }
  }

  private static class ManagedServlet extends HttpServlet {
    private final Provider servlet;

    public ManagedServlet(Provider servlet) {
      this.servlet = servlet;
    }

    @Override
    public void destroy() {
      servlet.get().destroy();
    }

    @Override
    public void init(ServletConfig config) throws ServletException {
      servlet.get().init(config);
    }

    @Override
    public void init() throws ServletException {
      servlet.get().init();
    }

    @Override
    public void log(String msg) {
      servlet.get().log(msg);
    }

    @Override
    public void log(String message, Throwable t) {
      servlet.get().log(message, t);
    }

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
      servlet.get().service(req, resp);
    }
  }    
}