Java Examples for org.eclipse.jetty.servlet.DefaultServlet

@Test
public void testWithServletConfiguration() throws Exception {
    assertThat(builder.servletConfigurations, is(notNullValue()));
    assertThat(builder.servletConfigurations.size(), equalTo(0));
    ServletConfiguration.Builder servletConfigBuilder = new ServletConfiguration.Builder();
    servletConfigBuilder.withServletClass(DefaultServlet.class).withServletName("superServlet").withInitOrder(1).withInitParameter("k1", "v1").withPathSpec("/css/*").withPathSpec("/js/*");
    ServletConfiguration servletConfiguration = servletConfigBuilder.build();
    builder.withServletConfiguration(servletConfiguration);
    assertThat(builder.servletConfigurations.size(), equalTo(1));
    assertThat(builder.servletConfigurations.contains(servletConfiguration), equalTo(true));
}

public static void main(final String[] args) throws Exception {
    SLF4JBridgeHandler.removeHandlersForRootLogger();
    SLF4JBridgeHandler.install();
    final Server server = new Server(9090);
    final ServletContextHandler sch = new ServletContextHandler(server, "/");
    sch.addEventListener(new ContextListener());
    sch.addFilter(GuiceFilter.class, "/*", EnumSet.of(DispatcherType.REQUEST));
    sch.addServlet(DefaultServlet.class, "/");
    server.start();
// Service is now accessible through
// http://localhost:9090/model/Practitioner
}

protected static void configureServer(Server server) throws Exception {
    setProtocol("http");
    setRealm(new Realm() {

        public String getId() {
            return "JdbcRealm";
        }

        public String getPrincipal() {
            return "jetty";
        }

        public String getCredentials() {
            return "jetty";
        }
    });
    SelectChannelConnector connector = new SelectChannelConnector();
    server.addConnector(connector);
    LoginService loginService = new JDBCLoginService("JdbcRealm", "./src/test/resources/jdbcrealm.properties");
    server.addBean(loginService);
    ConstraintSecurityHandler security = new ConstraintSecurityHandler();
    server.setHandler(security);
    Constraint constraint = new Constraint();
    constraint.setName("auth");
    constraint.setAuthenticate(true);
    constraint.setRoles(new String[] { "user", "admin" });
    ConstraintMapping mapping = new ConstraintMapping();
    mapping.setPathSpec("/*");
    mapping.setConstraint(constraint);
    Set<String> knownRoles = new HashSet<String>();
    knownRoles.add("user");
    knownRoles.add("admin");
    security.setConstraintMappings(Collections.singletonList(mapping), knownRoles);
    security.setAuthenticator(new BasicAuthenticator());
    security.setLoginService(loginService);
    security.setStrict(false);
    ServletContextHandler root = new ServletContextHandler();
    root.setContextPath("/");
    root.setResourceBase(getBasePath());
    ServletHolder servletHolder = new ServletHolder(new DefaultServlet());
    servletHolder.setInitParameter("gzip", "true");
    root.addServlet(servletHolder, "/*");
    Handler handler = new TestHandler(getBasePath());
    HandlerCollection handlers = new HandlerCollection();
    handlers.setHandlers(new Handler[] { handler, root });
    security.setHandler(handlers);
}

public static Server buildServer(Properties clbProps) {
    final Server server = new Server(determinePort());
    final ChecklistBankWsModule clbWs = new ChecklistBankSearchWsTestModule(clbProps);
    final ServletContextHandler root = new ServletContextHandler(server, "/", ServletContextHandler.NO_SESSIONS);
    root.addEventListener(clbWs);
    root.addFilter(GuiceFilter.class, "/*", null);
    root.addServlet(DefaultServlet.class, "/");
    server.setStopAtShutdown(true);
    return server;
}

protected static void configureServer(Server server) throws Exception {
    setProtocol("http");
    setRealm(new Realm() {

        public String getId() {
            return "JdbcRealm";
        }

        public String getPrincipal() {
            return "jetty";
        }

        public String getCredentials() {
            return "jetty";
        }
    });
    SelectChannelConnector connector = new SelectChannelConnector();
    server.addConnector(connector);
    LoginService loginService = new JDBCLoginService("JdbcRealm", "./src/test/resources/jdbcrealm.properties");
    server.addBean(loginService);
    ConstraintSecurityHandler security = new ConstraintSecurityHandler();
    server.setHandler(security);
    Constraint constraint = new Constraint();
    constraint.setName("auth");
    constraint.setAuthenticate(true);
    constraint.setRoles(new String[] { "user", "admin" });
    ConstraintMapping mapping = new ConstraintMapping();
    mapping.setPathSpec("/*");
    mapping.setConstraint(constraint);
    Set<String> knownRoles = new HashSet<String>();
    knownRoles.add("user");
    knownRoles.add("admin");
    security.setConstraintMappings(Collections.singletonList(mapping), knownRoles);
    security.setAuthenticator(new BasicAuthenticator());
    security.setLoginService(loginService);
    security.setStrict(false);
    ServletContextHandler root = new ServletContextHandler();
    root.setContextPath("/");
    root.setResourceBase(getBasePath());
    ServletHolder servletHolder = new ServletHolder(new DefaultServlet());
    servletHolder.setInitParameter("gzip", "true");
    root.addServlet(servletHolder, "/*");
    Handler handler = new TestHandler(getBasePath());
    HandlerCollection handlers = new HandlerCollection();
    handlers.setHandlers(new Handler[] { handler, root });
    security.setHandler(handlers);
}

public static void main(String[] args) throws Exception {
    Server server = new Server(8080);
    // Create the 'root' Spring application context
    final ServletContextHandler context = new ServletContextHandler();
    context.setContextPath("/");
    context.addEventListener(new ContextLoaderListener());
    context.setInitParameter("contextClass", AnnotationConfigWebApplicationContext.class.getName());
    context.setInitParameter("contextConfigLocation", AppConfig.class.getName());
    // Create default servlet (servlet api required)
    // The name of DefaultServlet should be set to 'defualt'.
    final ServletHolder defaultHolder = new ServletHolder("default", DefaultServlet.class);
    defaultHolder.setInitParameter("resourceBase", System.getProperty("user.dir"));
    context.addServlet(defaultHolder, "/");
    server.setHandler(context);
    WebSocketServerContainerInitializer.configureContext(context);
    server.start();
    server.join();
}

@Test
@Slow
public void testDefaultServletSuccess() throws Exception {
    int maxThreads = 10;
    QueuedThreadPool threadPool = new QueuedThreadPool(maxThreads, maxThreads);
    threadPool.setDetailedDump(true);
    _server = new Server(threadPool);
    // Prepare a big file to download.
    File directory = MavenTestingUtils.getTargetTestingDir();
    Files.createDirectories(directory.toPath());
    String resourceName = "resource.bin";
    Path resourcePath = Paths.get(directory.getPath(), resourceName);
    try (OutputStream output = Files.newOutputStream(resourcePath, StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
        byte[] chunk = new byte[1024];
        Arrays.fill(chunk, (byte) 'X');
        chunk[chunk.length - 2] = '\r';
        chunk[chunk.length - 1] = '\n';
        for (int i = 0; i < 256 * 1024; ++i) output.write(chunk);
    }
    final CountDownLatch writePending = new CountDownLatch(1);
    ServerConnector connector = new ServerConnector(_server, 0, 1) {

        @Override
        protected ChannelEndPoint newEndPoint(SocketChannel channel, ManagedSelector selectSet, SelectionKey key) throws IOException {
            return new SocketChannelEndPoint(channel, selectSet, key, getScheduler()) {

                @Override
                protected void onIncompleteFlush() {
                    super.onIncompleteFlush();
                    writePending.countDown();
                }
            };
        }
    };
    connector.setIdleTimeout(Long.MAX_VALUE);
    _server.addConnector(connector);
    ServletContextHandler context = new ServletContextHandler(_server, "/");
    context.setResourceBase(directory.toURI().toString());
    context.addServlet(DefaultServlet.class, "/*").setAsyncSupported(false);
    _server.setHandler(context);
    _server.start();
    List<Socket> sockets = new ArrayList<>();
    for (int i = 0; i < maxThreads * 2; ++i) {
        Socket socket = new Socket("localhost", connector.getLocalPort());
        sockets.add(socket);
        OutputStream output = socket.getOutputStream();
        String request = "" + "GET /" + resourceName + " HTTP/1.1\r\n" + "Host: localhost\r\n" + "\r\n";
        output.write(request.getBytes(StandardCharsets.UTF_8));
        output.flush();
        Thread.sleep(100);
    }
    // Wait for a the servlet to block.
    Assert.assertTrue(writePending.await(5, TimeUnit.SECONDS));
    long expected = Files.size(resourcePath);
    byte[] buffer = new byte[48 * 1024];
    List<Exchanger<Long>> totals = new ArrayList<>();
    for (Socket socket : sockets) {
        final Exchanger<Long> x = new Exchanger<>();
        totals.add(x);
        final InputStream input = socket.getInputStream();
        new Thread() {

            @Override
            public void run() {
                long total = 0;
                try {
                    // look for CRLFCRLF
                    StringBuilder header = new StringBuilder();
                    int state = 0;
                    while (state < 4 && header.length() < 2048) {
                        int ch = input.read();
                        if (ch < 0)
                            break;
                        header.append((char) ch);
                        switch(state) {
                            case 0:
                                if (ch == '\r')
                                    state = 1;
                                break;
                            case 1:
                                if (ch == '\n')
                                    state = 2;
                                else
                                    state = 0;
                                break;
                            case 2:
                                if (ch == '\r')
                                    state = 3;
                                else
                                    state = 0;
                                break;
                            case 3:
                                if (ch == '\n')
                                    state = 4;
                                else
                                    state = 0;
                                break;
                        }
                    }
                    while (total < expected) {
                        int read = input.read(buffer);
                        if (read < 0)
                            break;
                        total += read;
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        x.exchange(total);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }
    for (Exchanger<Long> x : totals) {
        Long total = x.exchange(-1L, 10000, TimeUnit.SECONDS);
        Assert.assertEquals(expected, total.longValue());
    }
    // We could read everything, good.
    for (Socket socket : sockets) socket.close();
}

public static void main(String[] args) throws Exception {
    System.out.println("Working directory: " + new File("./").getAbsolutePath().toString());
    Server server = new Server(9091);
    WebAppContext context = new WebAppContext();
    context.setDescriptor("/WEB-INF/web.xml");
    context.setResourceBase("src/main/webapp");
    context.setContextPath("/");
    context.setParentLoaderPriority(true);
    context.addServlet(DefaultServlet.class, "/*");
    server.setHandler(context);
    server.start();
    server.join();
}

@Override
protected void startUp() throws Exception {
    contextHandler.addFilter(new FilterHolder(guiceFilter), "/*", EnumSet.allOf(DispatcherType.class));
    contextHandler.addServlet(DefaultServlet.class.getCanonicalName(), "/");
    server.setHandler(contextHandler);
    server.start();
    log.log(Level.INFO, "Started HTTP Server at port {0}", ((ServerConnector) server.getConnectors()[0]).getLocalPort());
}

private Handler createServletHandler() {
    ServletContextHandler servletHandler = new ServletContextHandler();
    URL resourceUri = getClass().getClassLoader().getResource(STATIC_RESOURCE_DIR);
    if (resourceUri == null) {
        throw new IllegalStateException("Static resources directory was not found in classpath:" + STATIC_RESOURCE_DIR);
    } else {
        String staticDir = resourceUri.toExternalForm();
        servletHandler.setResourceBase(staticDir);
        servletHandler.setContextPath(".");
        servletHandler.addServlet(DefaultServlet.class, "/");
    }
    servletHandler.addServlet(AdminDispatcherServlet.class, mapping);
    return servletHandler;
}

public static void compose(Server server) {
    //Servlets + Guice
    ServletContextHandler servletContextHandler = new ServletContextHandler(server, "/", ServletContextHandler.SESSIONS);
    servletContextHandler.addFilter(GuiceFilter.class, "/*", EnumSet.allOf(DispatcherType.class));
    servletContextHandler.addServlet(DefaultServlet.class, "/");
    //JMX stuff...
    MBeanContainer mbContainer = new MBeanContainer(ManagementFactory.getPlatformMBeanServer());
    server.addEventListener(mbContainer);
    server.addBean(mbContainer);
    server.addBean(Log.getLog());
}

@BeforeClass
public void beforeClass() throws Exception {
    injector = getInjector();
    server = new Server(8080);
    ServletContextHandler handler = new ServletContextHandler(server, "/", ServletContextHandler.SESSIONS);
    handler.addFilter(GuiceFilter.class, "/*", EnumSet.allOf(DispatcherType.class));
    handler.addEventListener(new GuiceServletContextListener() {

        @Override
        protected Injector getInjector() {
            return injector;
        }
    });
    handler.addServlet(DefaultServlet.class, "/");
    server.start();
}

private void initHandler() {
    // default servlet required for jetty to accept all requests
    // (guice will define mappings between urls and servlets)
    ServletContextHandler handler = new ServletContextHandler(server, "/", ServletContextHandler.SESSIONS);
    handler.addFilter(GuiceFilter.class, "/*", EnumSet.allOf(DispatcherType.class));
    handler.addServlet(DefaultServlet.class, "/");
}

public static void main(String[] args) throws Exception {
    Server server = new Server(8182);
    ServletContextHandler handler = new ServletContextHandler();
    handler.setResourceBase("");
    handler.addEventListener(new GuiceConfig());
    handler.addFilter(GuiceFilter.class, "/*", null);
    handler.addServlet(DefaultServlet.class, "/");
    handler.setContextPath("/buggy");
    WebAppContext webAppContext = createContext("/todo", "js-backbone-todo");
    WebAppContext inheritance = createContext("/inheritance", "js-inheritance");
    WebAppContext arrays = createContext("/arrays", "js-array");
    WebAppContext require = createContext("/require", "js-requirejs");
    WebAppContext requireFromScratch = createContext("/scratch", "js-requirejs-from-scratch");
    WebAppContext backbone = createContext("/backbone", "js-backbone");
    ContextHandlerCollection contexts = new ContextHandlerCollection();
    contexts.setHandlers(new Handler[] { handler, webAppContext, arrays, backbone, require, inheritance, requireFromScratch });
    server.setHandler(contexts);
    server.start();
    server.join();
}

public static void main(String[] args) throws Exception {
    LOG.info("Starting PAAS");
    // Create the server.
    Server server = new Server(DEFAULT_PORT);
    // Create a servlet context and add the jersey servlet.
    ServletContextHandler sch = new ServletContextHandler(server, "/");
    // Add our Guice listener that includes our bindings
    sch.addEventListener(new PaasGuiceServletConfig());
    // Then add GuiceFilter and configure the server to 
    // reroute all requests through this filter. 
    sch.addFilter(GuiceFilter.class, "/*", null);
    // Must add DefaultServlet for embedded Jetty. 
    // Failing to do this will cause 404 errors.
    // This is not needed if web.xml is used instead.
    sch.addServlet(DefaultServlet.class, "/");
    // Start the server
    server.start();
    server.join();
    LOG.info("Stopping PAAS");
}

@Override
public void run(T configuration, Environment environment) {
    ShiroConfiguration shiroConfig = narrow(configuration);
    if (shiroConfig == null) {
        shiroConfig = new ShiroConfiguration();
    }
    ResourceConfig resourceConfig = environment.jersey().getResourceConfig();
    resourceConfig.register(StormpathShiroFeature.class);
    // This listener will configure Shiro and Stormpath
    environment.servlets().addServletListeners(new StormpathShiroEnvironmentLoaderListener());
    environment.servlets().addServlet("default", DefaultServlet.class).addMapping(// The Stormpath API requires the 'default' servlet
    "/");
    environment.servlets().addFilter("ShiroFilter", // setup the Shiro Filter
    ShiroFilter.class).addMappingForUrlPatterns(EnumSet.allOf(DispatcherType.class), false, shiroConfig.filterUrlPattern());
}

public static void main(String[] args) throws Exception {
    long startTime = System.currentTimeMillis();
    StreamflowConfig streamflowConfig = ConfigLoader.getConfig();
    LOG.info("Streamflow Server: Binding server to port " + streamflowConfig.getServer().getPort());
    ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
    context.setContextPath("/");
    context.addEventListener(new WebConfig());
    context.addFilter(GuiceFilter.class, "/*", EnumSet.of(DispatcherType.REQUEST));
    context.setWelcomeFiles(new String[] { "index.htm", "index.html" });
    context.setBaseResource(Resource.newClassPathResource("/assets"));
    context.addServlet(DefaultServlet.class, "/*");
    Server server = new Server(streamflowConfig.getServer().getPort());
    server.setHandler(context);
    server.start();
    double startupTime = (System.currentTimeMillis() - startTime) / 1000.0;
    LOG.info("Streamflow Server: Server started in " + startupTime + " seconds");
    server.join();
}

public static void main(final String[] args) throws Exception {
    // set timeout to 30min(60sec
    final int sessionTimeout = (int) Duration.minutes(30).seconds();
    // * 30min=1800sec)...
    // change this if your on production with deployment
    String configurationType;
    configurationType = "development";
    // configurationType = "deployment";
    System.setProperty("wicket.configuration", configurationType);
    final String projectname = getProjectName();
    final File projectDirectory = PathFinder.getProjectDirectory();
    final File webapp = PathFinder.getRelativePath(projectDirectory, projectname, "src", "main", "webapp");
    final String filterPath = "/*";
    final File logfile = new File(projectDirectory, "application.log");
    if (logfile.exists()) {
        try {
            DeleteFileExtensions.delete(logfile);
        } catch (final IOException e) {
            Logger.getRootLogger().error("logfile could not deleted.", e);
        }
    }
    final String absolutePathFromLogfile = logfile.getAbsolutePath();
    // Add a file appender to the logger programatically
    Logger.getRootLogger().addFileAppender(LoggerExtensions.newFileAppender(absolutePathFromLogfile));
    final ServletContextHandler servletContextHandler = ServletContextHandlerFactory.getNewServletContextHandler(ServletContextHandlerConfiguration.builder().filterHolderConfiguration(FilterHolderConfiguration.builder().filterClass(WicketFilter.class).name(projectname).filterPath(filterPath).initParameter(WicketFilter.FILTER_MAPPING_PARAM, filterPath).initParameter(ContextParamWebApplicationFactory.APP_CLASS_PARAM, WicketApplication.class.getName()).build()).servletHolderConfiguration(ServletHolderConfiguration.builder().servletClass(DefaultServlet.class).pathSpec(filterPath).build()).contextPath("/").webapp(webapp).maxInactiveInterval(sessionTimeout).filterPath(filterPath).initParameter("contextConfigLocation", "classpath:applicationContext.hbm.xml\nclasspath:applicationContext.xml").initParameter("configuration", configurationType).build());
    final Jetty9RunConfiguration configuration = newJetty9RunConfiguration(servletContextHandler);
    final Server server = new Server();
    Jetty9Runner.runServletContextHandler(server, configuration);
}

@Provides
@Singleton
Server provideServer(Environment env, ShutdownManager shutdownManager) {
    Server server = new Server();
    ServerConnector connector = new ServerConnector(server);
    connector.setPort(12025);
    server.addConnector(connector);
    ServletContextHandler handler = new ServletContextHandler();
    handler.setContextPath("/");
    DefaultServlet servlet = new DefaultServlet();
    ServletHolder holder = new ServletHolder(servlet);
    handler.addServlet(holder, "/*");
    handler.setResourceBase(env.getProperty("bq.internaljetty.base"));
    server.setHandler(handler);
    shutdownManager.addShutdownHook(() -> {
        server.stop();
    });
    return server;
}

public static void main(String[] args) throws Exception {
    Server server = new Server(8080);
    ServletContextHandler context = new ServletContextHandler(server, "/", ServletContextHandler.SESSIONS | ServletContextHandler.SECURITY);
    context.addServlet(new ServletHolder(new DefaultServlet() {

        private static final long serialVersionUID = 1L;

        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            response.getWriter().append("hello " + request.getUserPrincipal().getName());
        }
    }), "/*");
    context.addServlet(new ServletHolder(new LoginServlet2()), "/login");
    Constraint constraint = new Constraint();
    constraint.setName(Constraint.__FORM_AUTH);
    constraint.setRoles(new String[] { "user", "admin", "moderator" });
    constraint.setAuthenticate(true);
    ConstraintMapping constraintMapping = new ConstraintMapping();
    constraintMapping.setConstraint(constraint);
    constraintMapping.setPathSpec("/*");
    ConstraintSecurityHandler securityHandler = new ConstraintSecurityHandler();
    securityHandler.addConstraintMapping(constraintMapping);
    HashLoginService loginService = new HashLoginService();
    loginService.putUser("oshai", new Password("oshai"), new String[] { "user" });
    securityHandler.setLoginService(loginService);
    FormAuthenticator authenticator = new FormAuthenticator("/login", "/login", false);
    securityHandler.setAuthenticator(authenticator);
    context.setSecurityHandler(securityHandler);
    server.start();
    server.join();
// boot(Component.SIMPLE, SimpleServerBootstrap.class);
}

public static Server startWebsiteInState1Ntlm() {
    String name = "animalsStateV1";
    ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
    context.setContextPath("/");
    context.addFilter(NtlmAuthenticationFilter.class, "/*", EnumSet.of(DispatcherType.REQUEST));
    DefaultServlet defaultServlet = new DefaultServlet();
    ServletHolder servletHolder = new ServletHolder("default", defaultServlet);
    String ressourcePath = getFile(name).getAbsolutePath();
    servletHolder.setInitParameter("resourceBase", ressourcePath);
    context.addServlet(servletHolder, "/*");
    Server server = startWebsite(name, context);
    return server;
}

@Test
public void testUpDownWithServlets() throws Exception {
    setUpBus(true);
    Bus bus = (Bus) applicationContext.getBean("cxf");
    ServerRegistry sr = bus.getExtension(ServerRegistry.class);
    ServerImpl si = (ServerImpl) sr.getServers().get(0);
    JettyHTTPDestination jhd = (JettyHTTPDestination) si.getDestination();
    JettyHTTPServerEngine e = (JettyHTTPServerEngine) jhd.getEngine();
    org.eclipse.jetty.server.Server jettyServer = e.getServer();
    Handler[] contexts = jettyServer.getChildHandlersByClass(WebAppContext.class);
    WebAppContext servletContext = null;
    for (Handler h : contexts) {
        WebAppContext wac = (WebAppContext) h;
        if (wac.getContextPath().equals("/jsunit")) {
            servletContext = wac;
            break;
        }
    }
    servletContext.addServlet("org.eclipse.jetty.servlet.DefaultServlet", "/bloop");
    getTestHtml();
    invokeService();
    shutdownService();
    verifyNoServer(PORT2);
    verifyNoServer(PORT1);
}

public static void startServer() {
    if (server != null) {
        return;
    }
    server = new Server(5800);
    ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
    context.setContextPath("/");
    server.setHandler(context);
    // Add websocket servlet
    ServletHolder wsHolder = new ServletHolder("echo", new StateStreamServlet());
    context.addServlet(wsHolder, "/state");
    ServletHolder statesHolder = new ServletHolder("states", new GetAllStatesServlet());
    context.addServlet(statesHolder, "/all_states");
    ServletHolder keysHolder = new ServletHolder("keys", new GetKeysServlet());
    context.addServlet(keysHolder, "/keys");
    ServletHolder constantsHolder = new ServletHolder("constants", new ConstantsServlet());
    context.addServlet(constantsHolder, "/constants");
    ServletHolder getAutoModesHolder = new ServletHolder("autoModes", new GetAutoModesServlet());
    context.addServlet(getAutoModesHolder, "/autoModes");
    ServletHolder getCurrentAutoModeHolder = new ServletHolder("currentAutoModes", new GetCurrentAutoModeServlet());
    context.addServlet(getCurrentAutoModeHolder, "/currentAutoMode");
    ServletHolder setAutoModeHolder = new ServletHolder("setAutoMode", new SetAutoModeServlet());
    context.addServlet(setAutoModeHolder, "/setAutoMode");
    ServletHolder pingHolder = new ServletHolder("ping", new PingServlet());
    context.addServlet(pingHolder, "/ping");
    //noinspection ConstantConditions
    String appDir = WebServer.class.getClassLoader().getResource("app/").toExternalForm();
    ServletHolder holderPwd = new ServletHolder("default", new DefaultServlet());
    holderPwd.setInitParameter("resourceBase", appDir);
    holderPwd.setInitParameter("dirAllowed", "true");
    context.addServlet(holderPwd, "/");
    Thread serverThread = new Thread(new Runnable() {

        @Override
        public void run() {
            try {
                server.start();
                server.join();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    });
    serverThread.setPriority(Thread.MIN_PRIORITY);
    serverThread.start();
    streamUpdate.start();
}

protected Server startServer(final Module... modules) throws Exception {
    final Injector injector = Guice.createInjector(modules);
    final Server server = new Server(getPort());
    final ServletContextHandler servletContextHandler = new ServletContextHandler();
    servletContextHandler.addEventListener(new GuiceServletContextListener() {

        @Override
        protected Injector getInjector() {
            return injector;
        }
    });
    servletContextHandler.addFilter(GuiceFilter.class, "/*", null);
    servletContextHandler.addServlet(DefaultServlet.class, "/*");
    server.setHandler(servletContextHandler);
    server.start();
    final Thread t = new Thread() {

        @Override
        public void run() {
            try {
                server.join();
            } catch (final InterruptedException ignored) {
            }
        }
    };
    t.setDaemon(true);
    t.start();
    Assert.assertTrue(server.isRunning());
    return server;
}

@Override
public void lifeCycleStarting(LifeCycle event) {
    handler.getServletContext().setExtendedListenerTypes(true);
    Iterable<ServletContainerInitializer> initializers = servletContainer.getInitializers();
    for (ServletContainerInitializer servletContainerInitializer : initializers) {
        try {
            servletContainerInitializer.onStartup(Collections.emptySet(), handler.getServletContext());
        } catch (ServletException ex) {
            throw new RuntimeException(ex);
        }
    }
    handler.addServlet(DefaultServlet.class, "/");
    handler.getServletContext().setExtendedListenerTypes(false);
}

@Override
public void run() {
    Server server = new Server(23333);
    try {
        ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
        context.setContextPath("/");
        ServletHolder wsHolder = new ServletHolder("echo", new WebSocketServlet() {

            @Override
            public void configure(WebSocketServletFactory factory) {
                factory.register(WebSocketHandler.class);
            }
        });
        context.addServlet(wsHolder, "/w");
        URI uri = OmniOcular.class.getResource("/assets/omniocular/static/").toURI();
        context.setBaseResource(Resource.newResource(uri));
        context.setWelcomeFiles(new String[] { "index.html" });
        ServletHolder holderPwd = new ServletHolder("default", DefaultServlet.class);
        holderPwd.setInitParameter("cacheControl", "max-age=0,public");
        holderPwd.setInitParameter("useFileMappedBuffer", "false");
        context.addServlet(holderPwd, "/");
        server.setHandler(context);
        server.start();
        server.join();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

private static void createServer(int port) throws Exception {
    Server server = new Server(port);
    ServletContextHandler handler = new ServletContextHandler();
    handler.setResourceBase("war");
    handler.addServlet(new ServletHolder(new GwtQuakeServlet()), "/GwtQuake.html");
    handler.addServlet(new ServletHolder(new DefaultServlet()), "/*");
    server.setHandler(handler);
    server.start();
}

@BeforeClass(alwaysRun = true)
public void setUpGlobal() throws Exception {
    port = findFreePort();
    server = new Server(port);
    acceptHeader = AddressBookAction.APPLICATION + "/" + AddressBookAction.JSON;
    targetUrl = "http://127.0.0.1:" + port;
    ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
    context.setContextPath("/");
    context.addFilter(GuiceFilter.class, "/*", 0);
    context.addEventListener(new AddressBookSitebricksConfig());
    context.addServlet(DefaultServlet.class, "/");
    server.setHandler(context);
    server.start();
    logger.info("Local HTTP server started successfully");
}

@BeforeClass
public static void init() throws Exception {
    server = new Server(8080);
    ServletContextHandler context = new ServletContextHandler();
    ServletHolder defaultServ = new ServletHolder("default", DefaultServlet.class);
    defaultServ.setInitParameter("resourceBase", System.getProperty("user.dir"));
    defaultServ.setInitParameter("dirAllowed", "true");
    context.addServlet(defaultServ, "/");
    server.setHandler(context);
    server.start();
}

public static void main(String[] args) throws Exception {
    final List<AbstractModule> modules = Lists.newArrayList(new SimSchlepModule(), new SchlepModule(), new EventBusModule(), new AbstractModule() {

        @Override
        protected void configure() {
        }
    }, new JerseyServletModule() {

        @Override
        protected void configureServlets() {
            LOG.info("Binding jersey servlets");
            bind(BridgeAdminResource.class).asEagerSingleton();
            bind(JsonMessageBodyReader.class).asEagerSingleton();
            bind(JsonMessageBodyWriter.class).asEagerSingleton();
            // Route all requests through GuiceContainer
            bind(GuiceContainer.class).asEagerSingleton();
            serve("/*").with(GuiceContainer.class);
        }
    });
    LOG.info("Starting application");
    // Create the server.
    Server server = new Server(8080);
    ServletContextHandler sch = new ServletContextHandler(server, "/");
    final Injector injector = LifecycleInjector.builder().withModules(modules).createInjector();
    // Add our Guice listener that includes our bindings
    sch.addEventListener(new GuiceServletContextListener() {

        @Override
        protected Injector getInjector() {
            return injector;
        }
    });
    sch.addFilter(GuiceFilter.class, "/*", null);
    sch.addServlet(DefaultServlet.class, "/");
    LifecycleManager manager = injector.getInstance(LifecycleManager.class);
    try {
        manager.start();
        // Start the server
        server.start();
        server.join();
    } finally {
        LOG.info("Stopping application");
        Closeables.close(manager, true);
    }
}

@SuppressWarnings("deprecation")
public void run() throws Exception {
    setupJulLogging();
    performStaticInjection();
    initDB();
    server = new Server();
    server.setSessionIdManager(sessionIdManager);
    server.setSendServerVersion(false);
    Server serverForAgent = new Server();
    setSystemProperties(configs);
    runDatabaseConsistencyCheck();
    try {
        ClassPathXmlApplicationContext parentSpringAppContext = new ClassPathXmlApplicationContext();
        parentSpringAppContext.refresh();
        ConfigurableListableBeanFactory factory = parentSpringAppContext.getBeanFactory();
        factory.registerSingleton("guiceInjector", injector);
        factory.registerSingleton("ambariConfiguration", injector.getInstance(Configuration.class));
        factory.registerSingleton("ambariUsers", injector.getInstance(Users.class));
        factory.registerSingleton("passwordEncoder", injector.getInstance(PasswordEncoder.class));
        factory.registerSingleton("auditLogger", injector.getInstance(AuditLogger.class));
        factory.registerSingleton("permissionHelper", injector.getInstance(PermissionHelper.class));
        factory.registerSingleton("ambariLdapAuthenticationProvider", injector.getInstance(AmbariLdapAuthenticationProvider.class));
        factory.registerSingleton("ambariLocalAuthenticationProvider", injector.getInstance(AmbariLocalUserProvider.class));
        factory.registerSingleton("ambariLdapDataPopulator", injector.getInstance(AmbariLdapDataPopulator.class));
        factory.registerSingleton("ambariUserAuthorizationFilter", injector.getInstance(AmbariUserAuthorizationFilter.class));
        factory.registerSingleton("ambariInternalAuthenticationProvider", injector.getInstance(AmbariInternalAuthenticationProvider.class));
        factory.registerSingleton("ambariPamAuthenticationProvider", injector.getInstance(AmbariPamAuthenticationProvider.class));
        // Spring Security xml config depends on this Bean
        String[] contextLocations = { SPRING_CONTEXT_LOCATION };
        ClassPathXmlApplicationContext springAppContext = new ClassPathXmlApplicationContext(contextLocations, parentSpringAppContext);
        ServletContextHandler root = new ServletContextHandler(ServletContextHandler.SECURITY | ServletContextHandler.SESSIONS);
        configureRootHandler(root);
        configureSessionManager(sessionManager);
        root.getSessionHandler().setSessionManager(sessionManager);
        // setting ambari web context
        GenericWebApplicationContext springWebAppContext = new GenericWebApplicationContext();
        springWebAppContext.setServletContext(root.getServletContext());
        springWebAppContext.setParent(springAppContext);
        root.getServletContext().setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, springWebAppContext);
        certMan.initRootCert();
        // the agent communication (heartbeats, registration, etc) is stateless
        // and does not use sessions.
        ServletContextHandler agentroot = new ServletContextHandler(serverForAgent, "/", ServletContextHandler.NO_SESSIONS);
        if (configs.isAgentApiGzipped()) {
            configureHandlerCompression(agentroot);
        }
        ServletHolder rootServlet = root.addServlet(DefaultServlet.class, "/");
        rootServlet.setInitParameter("dirAllowed", "false");
        rootServlet.setInitOrder(1);
        /* Configure default servlet for agent server */
        rootServlet = agentroot.addServlet(DefaultServlet.class, "/");
        rootServlet.setInitOrder(1);
        // Conditionally adds security-related headers to all HTTP responses.
        root.addFilter(new FilterHolder(injector.getInstance(AmbariServerSecurityHeaderFilter.class)), "/*", DISPATCHER_TYPES);
        // The security header filter - conditionally adds security-related headers to the HTTP response for Ambari Views
        // requests.
        root.addFilter(new FilterHolder(injector.getInstance(AmbariViewsSecurityHeaderFilter.class)), VIEWS_URL_PATTERN, DISPATCHER_TYPES);
        // since views share the REST API threadpool, a misbehaving view could
        // consume all of the available threads and effectively cause a loss of
        // service for Ambari
        root.addFilter(new FilterHolder(injector.getInstance(ViewThrottleFilter.class)), VIEWS_URL_PATTERN, DISPATCHER_TYPES);
        // adds MDC info for views logging
        root.addFilter(new FilterHolder(injector.getInstance(AmbariViewsMDCLoggingFilter.class)), VIEWS_URL_PATTERN, DISPATCHER_TYPES);
        // session-per-request strategy for api
        root.addFilter(new FilterHolder(injector.getInstance(AmbariPersistFilter.class)), "/api/*", DISPATCHER_TYPES);
        root.addFilter(new FilterHolder(new MethodOverrideFilter()), "/api/*", DISPATCHER_TYPES);
        // register listener to capture request context
        root.addEventListener(new RequestContextListener());
        root.addFilter(new FilterHolder(springSecurityFilter), "/api/*", DISPATCHER_TYPES);
        root.addFilter(new FilterHolder(new UserNameOverrideFilter()), "/api/v1/users/*", DISPATCHER_TYPES);
        // session-per-request strategy for agents
        agentroot.addFilter(new FilterHolder(injector.getInstance(AmbariPersistFilter.class)), "/agent/*", DISPATCHER_TYPES);
        agentroot.addFilter(SecurityFilter.class, "/*", DISPATCHER_TYPES);
        Map<String, String> configsMap = configs.getConfigsMap();
        // Agents download cert on on-way connector but always communicate on
        // two-way connector for server-agent communication
        SelectChannelConnector agentOneWayConnector = createSelectChannelConnectorForAgent(configs.getOneWayAuthPort(), false);
        SelectChannelConnector agentTwoWayConnector = createSelectChannelConnectorForAgent(configs.getTwoWayAuthPort(), configs.isTwoWaySsl());
        // Override acceptor defaults if configured or use Jetty defaults
        Integer acceptors = configs.getAgentApiAcceptors() != null ? configs.getAgentApiAcceptors() : agentOneWayConnector.getAcceptors();
        agentOneWayConnector.setAcceptors(acceptors);
        agentTwoWayConnector.setAcceptors(acceptors);
        // Agent Jetty thread pool - widen the thread pool if needed !
        configureJettyThreadPool(serverForAgent, acceptors * 2, AGENT_THREAD_POOL_NAME, configs.getAgentThreadPoolSize());
        serverForAgent.addConnector(agentOneWayConnector);
        serverForAgent.addConnector(agentTwoWayConnector);
        ServletHolder sh = new ServletHolder(ServletContainer.class);
        sh.setInitParameter("com.sun.jersey.config.property.resourceConfigClass", "com.sun.jersey.api.core.PackagesResourceConfig");
        sh.setInitParameter("com.sun.jersey.config.property.packages", "org.apache.ambari.server.api.rest;" + "org.apache.ambari.server.api.services;" + "org.apache.ambari.eventdb.webservice;" + "org.apache.ambari.server.api");
        sh.setInitParameter("com.sun.jersey.api.json.POJOMappingFeature", "true");
        root.addServlet(sh, "/api/v1/*");
        sh.setInitOrder(2);
        SecurityContextHolder.setStrategyName(SecurityContextHolder.MODE_INHERITABLETHREADLOCAL);
        viewRegistry.readViewArchives();
        //Check and load requestlog handler.
        loadRequestlogHandler(handlerList, serverForAgent, configsMap);
        enableLog4jMonitor(configsMap);
        handlerList.addHandler(root);
        server.setHandler(handlerList);
        ServletHolder agent = new ServletHolder(ServletContainer.class);
        agent.setInitParameter("com.sun.jersey.config.property.resourceConfigClass", "com.sun.jersey.api.core.PackagesResourceConfig");
        agent.setInitParameter("com.sun.jersey.config.property.packages", "org.apache.ambari.server.agent.rest;" + "org.apache.ambari.server.api");
        agent.setInitParameter("com.sun.jersey.api.json.POJOMappingFeature", "true");
        agentroot.addServlet(agent, "/agent/v1/*");
        agent.setInitOrder(3);
        AgentResource.statHeartBeatHandler();
        LOG.info("********** Started Heartbeat handler **********");
        ServletHolder cert = new ServletHolder(ServletContainer.class);
        cert.setInitParameter("com.sun.jersey.config.property.resourceConfigClass", "com.sun.jersey.api.core.PackagesResourceConfig");
        cert.setInitParameter("com.sun.jersey.config.property.packages", "org.apache.ambari.server.security.unsecured.rest;" + "org.apache.ambari.server.api");
        cert.setInitParameter("com.sun.jersey.api.json.POJOMappingFeature", "true");
        agentroot.addServlet(cert, "/*");
        cert.setInitOrder(4);
        ServletHolder resources = new ServletHolder(ServletContainer.class);
        resources.setInitParameter("com.sun.jersey.config.property.resourceConfigClass", "com.sun.jersey.api.core.PackagesResourceConfig");
        resources.setInitParameter("com.sun.jersey.config.property.packages", "org.apache.ambari.server.resources.api.rest;");
        root.addServlet(resources, "/resources/*");
        resources.setInitOrder(5);
        if (configs.csrfProtectionEnabled()) {
            sh.setInitParameter("com.sun.jersey.spi.container.ContainerRequestFilters", "org.apache.ambari.server.api.AmbariCsrfProtectionFilter");
        }
        /* Configure the API server to use the NIO connectors */
        SelectChannelConnector apiConnector = createSelectChannelConnectorForClient();
        acceptors = configs.getClientApiAcceptors() != null ? configs.getClientApiAcceptors() : apiConnector.getAcceptors();
        apiConnector.setAcceptors(acceptors);
        // Client Jetty thread pool - widen the thread pool if needed !
        configureJettyThreadPool(server, acceptors, CLIENT_THREAD_POOL_NAME, configs.getClientThreadPoolSize());
        server.addConnector(apiConnector);
        server.setStopAtShutdown(true);
        serverForAgent.setStopAtShutdown(true);
        springAppContext.start();
        String osType = getServerOsType();
        if (osType == null || osType.isEmpty()) {
            throw new RuntimeException(Configuration.OS_VERSION.getKey() + " is not " + " set in the ambari.properties file");
        }
        //Start action scheduler
        LOG.info("********* Initializing Clusters **********");
        Clusters clusters = injector.getInstance(Clusters.class);
        StringBuilder clusterDump = new StringBuilder();
        clusters.debugDump(clusterDump);
        LOG.info("********* Current Clusters State *********");
        LOG.info(clusterDump.toString());
        LOG.info("********* Reconciling Alert Definitions **********");
        ambariMetaInfo.reconcileAlertDefinitions(clusters);
        LOG.info("********* Initializing ActionManager **********");
        ActionManager manager = injector.getInstance(ActionManager.class);
        LOG.info("********* Initializing Controller **********");
        AmbariManagementController controller = injector.getInstance(AmbariManagementController.class);
        LOG.info("********* Initializing Scheduled Request Manager **********");
        ExecutionScheduleManager executionScheduleManager = injector.getInstance(ExecutionScheduleManager.class);
        MetricsService metricsService = injector.getInstance(MetricsService.class);
        clusterController = controller;
        StateRecoveryManager recoveryManager = injector.getInstance(StateRecoveryManager.class);
        recoveryManager.doWork();
        /*
       * Start the server after controller state is recovered.
       */
        server.start();
        serverForAgent.start();
        LOG.info("********* Started Server **********");
        if (!configs.isViewDirectoryWatcherServiceDisabled()) {
            LOG.info("Starting View Directory Watcher");
            viewDirectoryWatcher.start();
        }
        manager.start();
        LOG.info("********* Started ActionManager **********");
        executionScheduleManager.start();
        LOG.info("********* Started Scheduled Request Manager **********");
        serviceManager.startAsync();
        LOG.info("********* Started Services **********");
        if (!configs.isMetricsServiceDisabled()) {
            metricsService.start();
        } else {
            LOG.info("AmbariServer Metrics disabled.");
        }
        server.join();
        LOG.info("Joined the Server");
    } catch (BadPaddingException bpe) {
        LOG.error("Bad keystore or private key password. " + "HTTPS certificate re-importing may be required.");
        throw bpe;
    } catch (BindException bindException) {
        LOG.error("Could not bind to server port - instance may already be running. " + "Terminating this instance.", bindException);
        throw bindException;
    }
}

public void run() throws Exception {
    BufferedReader console = new BufferedReader(new InputStreamReader(System.in));
    int port = this.port;
    if (interactive) {
        System.err.printf("listen port [%d]: ", port);
        String value = console.readLine().trim();
        if (value.length() == 0) {
            value = String.valueOf(port);
        }
        port = Integer.parseInt(value);
    }
    boolean tls = this.tls;
    if (interactive) {
        System.err.printf("use tls [%b]: ", tls);
        String value = console.readLine().trim();
        if (value.length() == 0) {
            value = String.valueOf(tls);
        }
        tls = Boolean.parseBoolean(value);
    }
    int selectors = this.selectors;
    if (interactive) {
        System.err.printf("selectors [%d]: ", selectors);
        String value = console.readLine().trim();
        if (value.length() == 0) {
            value = String.valueOf(selectors);
        }
        selectors = Integer.parseInt(value);
    }
    int maxThreads = this.maxThreads;
    if (interactive) {
        maxThreads = Integer.parseInt(System.getProperty("cometd.threads", String.valueOf(maxThreads)));
        System.err.printf("max threads [%d]: ", maxThreads);
        String value = console.readLine().trim();
        if (value.length() == 0) {
            value = String.valueOf(maxThreads);
        }
        maxThreads = Integer.parseInt(value);
    }
    bayeuxServer.addExtension(new AcknowledgedMessagesExtension());
    String availableTransports = "jsrws,jettyws,http,asynchttp";
    String transports = this.transports;
    if (interactive) {
        System.err.printf("transports (%s) [%s]: ", availableTransports, transports);
        String value = console.readLine().trim();
        if (value.length() == 0) {
            value = transports;
        }
        transports = value;
    }
    for (String token : transports.split(",")) {
        switch(token.trim()) {
            case "jsrws":
                bayeuxServer.addTransport(new WebSocketTransport(bayeuxServer));
                break;
            case "jettyws":
                bayeuxServer.addTransport(new JettyWebSocketTransport(bayeuxServer));
                break;
            case "http":
                bayeuxServer.addTransport(new JSONTransport(bayeuxServer));
                break;
            case "asynchttp":
                bayeuxServer.addTransport(new AsyncJSONTransport(bayeuxServer));
                break;
            default:
                throw new IllegalArgumentException("Invalid transport: " + token);
        }
    }
    boolean statistics = this.statistics;
    if (interactive) {
        System.err.printf("record statistics [%b]: ", statistics);
        String value = console.readLine().trim();
        if (value.length() == 0) {
            value = String.valueOf(statistics);
        }
        statistics = Boolean.parseBoolean(value);
    }
    boolean latencies = this.latencies;
    if (interactive) {
        System.err.printf("record latencies [%b]: ", latencies);
        String value = console.readLine().trim();
        if (value.length() == 0) {
            value = String.valueOf(latencies);
        }
        latencies = Boolean.parseBoolean(value);
    }
    boolean longRequests = this.longRequests;
    if (interactive) {
        System.err.printf("detect long requests [%b]: ", longRequests);
        String value = console.readLine().trim();
        if (value.length() == 0) {
            value = String.valueOf(longRequests);
        }
        longRequests = Boolean.parseBoolean(value);
    }
    jettyThreadPool.setMaxThreads(maxThreads);
    // Setup JMX
    MBeanContainer mbeanContainer = new MBeanContainer(ManagementFactory.getPlatformMBeanServer());
    server.addBean(mbeanContainer);
    SslContextFactory sslContextFactory = null;
    if (tls) {
        Path keyStoreFile = Paths.get("src/main/resources/keystore.jks");
        if (Files.exists(keyStoreFile)) {
            throw new FileNotFoundException(keyStoreFile.toString());
        }
        sslContextFactory = new SslContextFactory();
        sslContextFactory.setKeyStorePath(keyStoreFile.toString());
        sslContextFactory.setKeyStorePassword("storepwd");
        sslContextFactory.setKeyManagerPassword("keypwd");
    }
    HttpConfiguration httpConfiguration = new HttpConfiguration();
    httpConfiguration.setDelayDispatchUntilContent(true);
    HttpConnectionFactory httpConnectionFactory = new HttpConnectionFactory(httpConfiguration);
    ConnectionFactory[] factories = AbstractConnectionFactory.getFactories(sslContextFactory, httpConnectionFactory);
    ServerConnector connector = new ServerConnector(server, null, null, null, 1, selectors, factories);
    // Make sure the OS is configured properly for load testing;
    // see http://cometd.org/documentation/howtos/loadtesting
    connector.setAcceptQueueSize(2048);
    // Make sure the server timeout on a TCP connection is large
    connector.setIdleTimeout(50 * Config.MAX_NETWORK_DELAY);
    connector.setPort(port);
    server.addConnector(connector);
    HandlerWrapper handler = server;
    if (latencies) {
        requestLatencyHandler = new RequestLatencyHandler();
        handler.setHandler(requestLatencyHandler);
        handler = requestLatencyHandler;
    }
    if (longRequests) {
        RequestQoSHandler requestQoSHandler = new RequestQoSHandler();
        handler.setHandler(requestQoSHandler);
        handler = requestQoSHandler;
    }
    if (statistics) {
        statisticsHandler = new StatisticsHandler();
        handler.setHandler(statisticsHandler);
        handler = statisticsHandler;
    }
    // Add more handlers if needed
    ServletContextHandler context = new ServletContextHandler(handler, Config.CONTEXT_PATH, ServletContextHandler.SESSIONS);
    context.setAttribute(BayeuxServer.ATTRIBUTE, bayeuxServer);
    context.setInitParameter(ServletContextHandler.MANAGED_ATTRIBUTES, BayeuxServer.ATTRIBUTE);
    WebSocketServerContainerInitializer.configureContext(context);
    // Setup default servlet to serve static files
    context.addServlet(DefaultServlet.class, "/");
    // Setup comet servlet
    String cometdURLMapping = Config.SERVLET_PATH + "/*";
    CometDServlet cometServlet = new CometDServlet();
    ServletHolder cometdServletHolder = new ServletHolder(cometServlet);
    context.addServlet(cometdServletHolder, cometdURLMapping);
    // Make sure the expiration timeout is large to avoid clients to timeout
    // This value must be several times larger than the client value
    // (e.g. 60 s on server vs 5 s on client) so that it's guaranteed that
    // it will be the client to dispose idle connections.
    bayeuxServer.setOption(AbstractServerTransport.MAX_INTERVAL_OPTION, String.valueOf(10 * Config.MAX_NETWORK_DELAY));
    // Explicitly set the timeout value
    bayeuxServer.setOption(AbstractServerTransport.TIMEOUT_OPTION, String.valueOf(Config.META_CONNECT_TIMEOUT));
    // Use the faster JSON parser/generator
    bayeuxServer.setOption(AbstractServerTransport.JSON_CONTEXT_OPTION, JacksonJSONContextServer.class.getName());
    bayeuxServer.setOption("ws.cometdURLMapping", cometdURLMapping);
    bayeuxServer.setOption(ServletContext.class.getName(), context.getServletContext());
    server.start();
    new StatisticsService(this);
}

public void addFileServlet(ServletContextHandler context, String pathSpec, String fileRootPath) {
    ServletHolder servletHolder = new ServletHolder(DefaultServlet.class);
    servletHolder.setInitParameter("resourceBase", fileRootPath);
    servletHolder.setInitParameter("aliases", "true");
    context.addAliasCheck(new AllowSymLinkAliasChecker());
    context.addServlet(servletHolder, pathSpec);
}

public static Server createWebServer(final int port, final String resourceBase, final String[] classpath, final Map<String, Class<? extends Servlet>> servlets, final HandlerWrapper handler) throws Exception {
    final Server server = new Server(port);
    final WebAppContext context = new WebAppContext();
    context.setContextPath("/");
    context.setResourceBase(resourceBase);
    if (servlets != null) {
        for (final Map.Entry<String, Class<? extends Servlet>> entry : servlets.entrySet()) {
            final String pathSpec = entry.getKey();
            final Class<? extends Servlet> servlet = entry.getValue();
            context.addServlet(servlet, pathSpec);
            // disable defaults if someone likes to register his own root servlet
            if ("/".equals(pathSpec)) {
                context.setDefaultsDescriptor(null);
                context.addServlet(DefaultServlet.class, "/favicon.ico");
            }
        }
    }
    final WebAppClassLoader loader = new WebAppClassLoader(context);
    if (classpath != null) {
        for (final String path : classpath) {
            loader.addClassPath(path);
        }
    }
    context.setClassLoader(loader);
    if (handler != null) {
        handler.setHandler(context);
        server.setHandler(handler);
    } else {
        server.setHandler(context);
    }
    server.start();
    return server;
}

private Server getJettyServer(final Injector servletInjector) {
    Server jettyServer = new Server(jettyServerPort);
    final ServletContextHandler app = new ServletContextHandler();
    GuiceFilter filter = servletInjector.getInstance(GuiceFilter.class);
    app.addFilter(new FilterHolder(filter), "/*", EnumSet.of(DispatcherType.REQUEST, DispatcherType.ASYNC));
    app.addEventListener(new GuiceServletContextListener() {

        @Override
        protected Injector getInjector() {
            return servletInjector;
        }
    });
    // This servlet is never used but apparently Jetty requires at least one Servlet to run
    final ServletHolder ds = app.addServlet(DefaultServlet.class, "/");
    ds.setInitParameter("dirAllowed", "false");
    ds.setInitParameter("redirectWelcome", "false");
    ds.setInitParameter("useFileMappedBuffer", "false");
    ds.setInitParameter("gzip", "true");
    app.setSecurityHandler(getConfiguredSecurityHandler(app));
    jettyServer.setHandler(app);
    return jettyServer;
}

@BeforeClass
public void init() throws Exception {
    System.setProperty("archaius.deployment.applicationId", "scriptmanager-app");
    System.setProperty("archaius.deployment.environment", "dev");
    server = new Server(TEST_LOCAL_PORT);
    ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
    context.setContextPath("/");
    context.addEventListener(new KaryonGuiceContextListener());
    context.addFilter(GuiceFilter.class, "/*", 1);
    context.addServlet(DefaultServlet.class, "/");
    server.setHandler(context);
    server.start();
}

private ServletContextHandler createServletContextHandler(final String resourceBase, final Iterable<EventListener> eventListeners, final Map<FilterHolder, String> filterHolders) {
    final ServletContextHandler context = new ServletContextHandler(server, "/", ServletContextHandler.NO_SESSIONS);
    context.setContextPath("/");
    if (resourceBase != null) {
        // Required if you want a webapp directory. See ContextHandler#getResource and http://docs.codehaus.org/display/JETTY/Embedding+Jetty
        final String webapp = this.getClass().getClassLoader().getResource(resourceBase).toExternalForm();
        context.setResourceBase(webapp);
    }
    // Jersey insists on using java.util.logging (JUL)
    final EventListener listener = new SetupJULBridge();
    context.addEventListener(listener);
    for (final EventListener eventListener : eventListeners) {
        context.addEventListener(eventListener);
    }
    for (final FilterHolder filterHolder : filterHolders.keySet()) {
        context.addFilter(filterHolder, filterHolders.get(filterHolder), EnumSet.of(DispatcherType.REQUEST, DispatcherType.ASYNC));
    }
    // Make sure Guice filter all requests
    final FilterHolder filterHolder = new FilterHolder(GuiceFilter.class);
    context.addFilter(filterHolder, "/*", EnumSet.of(DispatcherType.REQUEST, DispatcherType.ASYNC));
    // Backend servlet for Guice - never used
    final ServletHolder sh = new ServletHolder(DefaultServlet.class);
    context.addServlet(sh, "/*");
    return context;
}

/**
	 * @param args
	 * @throws Exception 
	 */
public static void main(String[] args) throws Exception {
    String war_dir = "./war";
    String host = "localhost";
    int port = 8080;
    if (args.length > 0) {
        war_dir = args[0];
    }
    if (args.length > 1) {
        host = args[1];
    }
    if (args.length > 2) {
        port = Integer.parseInt(args[2]);
    }
    Server server = new Server();
    SelectChannelConnector connector = new SelectChannelConnector();
    connector.setHost(host);
    connector.setPort(port);
    server.addConnector(connector);
    ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
    context.setResourceBase(war_dir);
    ServletHolder holder = new ServletHolder(new GWTChatSocketServlet());
    holder.setInitParameter(FlashSocketTransport.FLASHPOLICY_SERVER_HOST_KEY, host);
    holder.setInitParameter(FlashSocketTransport.FLASHPOLICY_DOMAIN_KEY, host);
    holder.setInitParameter(FlashSocketTransport.FLASHPOLICY_PORTS_KEY, "" + port);
    context.addServlet(holder, "/socket.io/*");
    context.addServlet(new ServletHolder(new StaticServlet()), "/gwtchat.html");
    ServletHolder defaultServlet = new ServletHolder(new DefaultServlet());
    context.addServlet(defaultServlet, "/com.glines.socketio.examples.gwtchat.GWTChat/*");
    server.setHandler(context);
    server.start();
}

@Override
public void run() {
    Server server = new Server(config.getStatusServerPort());
    log.info("Starting status server on " + config.getStatusServerPort());
    // Create a servlet context and add the jersey servlet.
    ServletContextHandler sch = new ServletContextHandler(server, "/");
    // Add our Guice listener that includes our bindings
    sch.addEventListener(new GuiceServletContextListener() {

        @Override
        protected Injector getInjector() {
            return injector;
        }
    });
    // Then add GuiceFilter and configure the server to 
    // reroute all requests through this filter. 
    sch.addFilter(GuiceFilter.class, "/*", null);
    // Must add DefaultServlet for embedded Jetty. 
    // Failing to do this will cause 404 errors.
    // This is not needed if web.xml is used instead.
    sch.addServlet(DefaultServlet.class, "/");
    // Start the server
    try {
        server.start();
        startLatch.countDown();
        server.join();
    } catch (InterruptedException ie) {
        log.info("Interrupted to shutdown status server:");
    } catch (Exception e) {
        log.error("Failed to start status server", e);
    } finally {
        try {
            server.stop();
            log.info("StatusServer was shutdown");
        } catch (Exception e) {
            log.error("Failed to join status server", e);
        }
    }
}

private static Server configureServer() {
    Server server = new Server();
    Connector connector = new SelectChannelConnector();
    connector.setHost("0.0.0.0");
    connector.setPort(8090);
    server.setConnectors(new Connector[] { connector });
    ServletContextHandler contextHandler = new ServletContextHandler(server, "/", ServletContextHandler.NO_SESSIONS);
    contextHandler.addFilter(GuiceFilter.class, "/*", 0);
    contextHandler.addEventListener(new GuiceServletConfig());
    contextHandler.addServlet(DefaultServlet.class, "/");
    server.setThreadPool(new ExecutorThreadPool());
    return server;
}

private static void startJetty() throws Exception {
//		      server = new Server(8081);
//		       
//		      ServletContextHandler sch = new ServletContextHandler(server, "/");
//		       
//		      sch.addEventListener(new BaseServletListener());
//		      
//		      sch.addFilter(GuiceFilter.class, "/*", null);
//		      // Must add DefaultServlet for embedded Jetty.
//		      // Failing to do this will cause 404 errors.
//		      // This is not needed if web.xml is used instead.
//		      sch.addServlet(DefaultServlet.class, "/");
//		       
//		      sch.addFilter(GuiceFilter.class, "/*", null);
//		      // Start the server
//		      server.start();
//		      server.join();		
}

public void start() throws Exception {
    ((ServerConnector) server.getConnectors()[0]).setReuseAddress(true);
    // Root context
    context.setContextPath("/abnormal");
    // Setup static content
    context.setResourceBase("src/main/webapp/");
    context.addServlet(DefaultServlet.class, "/");
    // Enable Jersey debug output
    context.setInitParameter("com.sun.jersey.config.statistic.Trace", "true");
    // Enable CORS - cross origin resource sharing
    FilterHolder cors = new FilterHolder();
    cors.setInitParameter("allowedOrigins", "https?://localhost:*, https?://*.e-navigation.net:*");
    cors.setInitParameter("allowedHeaders", "*");
    cors.setInitParameter("allowedMethods", "OPTIONS,GET,PUT,POST,DELETE,HEAD");
    cors.setFilter(new CrossOriginFilter());
    context.addFilter(cors, "*", EnumSet.of(DispatcherType.REQUEST, DispatcherType.ASYNC, DispatcherType.INCLUDE));
    // Little hack to satisfy OpenLayers URLs in DMA context
    RewritePatternRule openlayersRewriteRule = new RewritePatternRule();
    openlayersRewriteRule.setPattern("/abnormal/theme/*");
    openlayersRewriteRule.setReplacement("/abnormal/js/theme/");
    RewriteHandler rewrite = new RewriteHandler();
    rewrite.setRewriteRequestURI(true);
    rewrite.setRewritePathInfo(false);
    rewrite.setOriginalPathAttribute("requestedPath");
    rewrite.addRule(openlayersRewriteRule);
    rewrite.setHandler(context);
    server.setHandler(rewrite);
    // Setup Guice-Jersey integration
    context.addEventListener(new GuiceServletContextListener() {

        @Override
        protected Injector getInjector() {
            return Guice.createInjector(new RestModule(repositoryName, pathToEventDatabase, eventRepositoryType, eventDataDbHost, eventDataDbPort, eventDataDbName, eventDataDbUsername, eventDataDbPassword));
        }
    });
    context.addFilter(com.google.inject.servlet.GuiceFilter.class, "/rest/*", EnumSet.allOf(DispatcherType.class));
    // Start the server
    server.start();
}

protected RemoteRepoInfo createServer(String id) throws Exception {
    RemoteRepoInfo repo = new RemoteRepoInfo();
    repo.id = id;
    repo.context = "/" + id;
    repo.root = repoRootInternali.getRoot();
    // Remove exising root contents.
    if (repo.root.exists()) {
        FileUtils.deleteDirectory(repo.root);
    }
    // Establish root directory.
    if (!repo.root.exists()) {
        repo.root.mkdirs();
    }
    repo.server = new Server(0);
    ContextHandlerCollection contexts = new ContextHandlerCollection();
    repo.server.setHandler(contexts);
    ServletContextHandler context = new ServletContextHandler();
    context.setContextPath(repo.context);
    context.setResourceBase(repo.root.getAbsolutePath());
    context.setAttribute("dirAllowed", true);
    context.setAttribute("maxCacheSize", 0);
    ServletHolder sh = new ServletHolder(DefaultServlet.class);
    context.addServlet(sh, "/");
    contexts.addHandler(context);
    repo.server.start();
    int port = repo.server.getConnectors()[0].getLocalPort();
    repo.url = "http://localhost:" + port + repo.context;
    log.info("Remote HTTP Server started on {}", repo.url);
    repo.config = createRemoteRepository(repo.id, "Testable [" + repo.id + "] Remote Repo", repo.url);
    return repo;
}

@Override
protected void configureServlets() {
    bind(HttpStatsFilter.class).in(Singleton.class);
    filter("*").through(HttpStatsFilter.class);
    bind(LeaderRedirectFilter.class).in(Singleton.class);
    filterRegex(allOf(LEADER_ENDPOINTS)).through(LeaderRedirectFilter.class);
    bind(GuiceContainer.class).in(Singleton.class);
    filterRegex(allOf(ImmutableSet.copyOf(JAX_RS_ENDPOINTS.values()))).through(GuiceContainer.class, GUICE_CONTAINER_PARAMS);
    filterRegex("/assets/scheduler(?:/.*)?").through(LeaderRedirectFilter.class);
    serve("/assets", "/assets/*").with(new DefaultServlet(), ImmutableMap.of("resourceBase", STATIC_ASSETS_ROOT, "dirAllowed", "false"));
    for (Class<?> jaxRsHandler : JAX_RS_ENDPOINTS.keySet()) {
        bind(jaxRsHandler);
    }
}

public static void main(String[] args) {
    Server server = new Server();
    ServerConnector connector = new ServerConnector(server);
    connector.setPort(8080);
    server.addConnector(connector);
    // Setup the basic application "context" for this application at "/"
    // This is also known as the handler tree (in jetty speak)
    ServletContextHandler context = new ServletContextHandler(ServletContextHandler.NO_SESSIONS);
    context.setContextPath("/");
    server.setHandler(context);
    context.addServlet(CoapRequestServlet.class, "/request");
    // add special pathspec of "/home/" content mapped to the homePath
    ServletHolder holderHome = new ServletHolder("static-home", DefaultServlet.class);
    //... contains: helloWorld.html, login.html, etc. and folder: other/xxx.html
    String baseStr = "/webapp";
    URL baseUrl = PolyfillProxy.class.getResource(baseStr);
    String basePath = baseUrl.toExternalForm();
    holderHome.setInitParameter("resourceBase", basePath);
    holderHome.setInitParameter("dirAllowed", "false");
    holderHome.setInitParameter("pathInfoOnly", "true");
    context.addServlet(holderHome, "/*");
    try {
        // Initialize javax.websocket layer
        ServerContainer wscontainer = WebSocketServerContainerInitializer.configureContext(context);
        // Add WebSocket endpoint to javax.websocket layer
        wscontainer.addEndpoint(ObserveSocket.class);
        server.start();
        server.dump(System.err);
        server.join();
    } catch (Throwable t) {
        t.printStackTrace(System.err);
    }
}

/**
     * �动内嵌的RESTful�务器.
     *
     * @param packages RESTful实现类所在包
     * @param resourcePath 资�路径
     * @param servletPath servlet路径
     * @throws Exception �动�务器异常
     */
public void start(final String packages, final Optional<String> resourcePath, final Optional<String> servletPath) throws Exception {
    log.info("Elastic Job: Start RESTful server");
    HandlerList handlers = new HandlerList();
    if (resourcePath.isPresent()) {
        servletContextHandler.setBaseResource(Resource.newClassPathResource(resourcePath.get()));
        servletContextHandler.addServlet(new ServletHolder(DefaultServlet.class), "/*");
    }
    String servletPathStr = (servletPath.isPresent() ? servletPath.get() : "") + "/*";
    servletContextHandler.addServlet(getServletHolder(packages), servletPathStr);
    handlers.addHandler(servletContextHandler);
    server.setHandler(handlers);
    server.start();
}

public void startServer() throws Exception {
    webServer = new Server();
    LOG.info("Starting RestAPI Server...");
    /**
         * TODO WHEN MOVING TO JETTY 9 refactor connectors code and add spdy
         * support
         * http://download.eclipse.org/jetty/stable-9/xref/org/eclipse/jetty/embedded/SpdyConnector.html
         *
         */
    if (!master.configuration.getBooleanProperty("enable-ssl", false)) {
        SelectChannelConnector selectChannelConnector = new SelectChannelConnector();
        selectChannelConnector.setPort(master.configuration.getIntProperty("http-port", 9111));
        webServer.addConnector(selectChannelConnector);
    } else {
        SslContextFactory sslContextFactory = new SslContextFactory();
        sslContextFactory.setKeyStorePassword(master.configuration.getStringProperty("KEYSTORE_SERVER_PWD", "freedomotic"));
        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
        keyStore.load(new FileInputStream(master.getFile().getParent() + "/data/" + master.configuration.getStringProperty("KEYSTORE_SERVER_FILE", "keystore_server")), master.configuration.getStringProperty("KEYSTORE_SERVER_PWD", "freedomotic").toCharArray());
        sslContextFactory.setKeyStore(keyStore);
        SslSelectChannelConnector sslSelectChannelConnector = new SslSelectChannelConnector(sslContextFactory);
        sslSelectChannelConnector.setPort(master.configuration.getIntProperty("https-port", 9113));
        webServer.addConnector(sslSelectChannelConnector);
    }
    ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
    context.setContextPath("/");
    // atmpsphere servlet 
    ServletHolder atmosphereServletHolder = new ServletHolder(AtmosphereServlet.class);
    atmosphereServletHolder.setInitParameter("jersey.config.server.provider.packages", RestAPIv3.ATMOSPHRE_RESOURCE_PKG);
    atmosphereServletHolder.setInitParameter("org.atmosphere.websocket.messageContentType", "application/json");
    atmosphereServletHolder.setInitParameter("org.atmosphere.cpr.AtmosphereInterceptor", "org.atmosphere.interceptor.ShiroInterceptor");
    //        atmosphereServletHolder.setInitParameter("org.atmosphere.cpr.broadcasterClass", "org.atmosphere.jersey.JerseyBroadcaster");
    atmosphereServletHolder.setAsyncSupported(true);
    atmosphereServletHolder.setInitParameter("org.atmosphere.useWebSocket", "true");
    atmosphereServletHolder.setInitOrder(2);
    context.addServlet(atmosphereServletHolder, "/" + API_VERSION + "/ws/*");
    // jersey servlet
    ServletHolder jerseyServletHolder = new ServletHolder(ServletContainer.class);
    jerseyServletHolder.setInitParameter("javax.ws.rs.Application", JerseyApplication.class.getCanonicalName());
    jerseyServletHolder.setInitParameter("jersey.config.server.wadl.disableWadl", "true");
    jerseyServletHolder.setInitOrder(1);
    context.addServlet(jerseyServletHolder, "/" + API_VERSION + "/*");
    // cors filter
    if (master.configuration.getBooleanProperty("enable-cors", false)) {
        FilterHolder corsFilterHolder = new FilterHolder(CrossOriginFilter.class);
        corsFilterHolder.setInitParameter("allowedOrigins", master.configuration.getStringProperty("Access-Control-Allow-Origin", "*"));
        corsFilterHolder.setInitParameter("allowedMethods", master.configuration.getStringProperty("Access-Control-Allow-Methods", "GET,PUT,HEAD,POST,DELETE"));
        corsFilterHolder.setInitParameter("allowedHeaders", master.configuration.getStringProperty("Access-Control-Allow-Headers", "Accept,Accept-Version,Authorization,Content-Length,Content-MD5,Content-Type,Date," + "Origin,X-Access-Token,X-Api-Version,X-CSRF-Token,X-File-Name,X-Requested-With"));
        corsFilterHolder.setInitParameter("allowCredentials", "true");
        context.addFilter(corsFilterHolder, "/*", null);
    }
    // shiro filter
    if (master.getApi().getAuth().isInited()) {
        context.addEventListener(new ShiroListener());
        context.addFilter(ShiroFilter.class, "/*", null);
    }
    // guice filter
    context.addEventListener(guiceServletConfig);
    context.addFilter(GuiceFilter.class, "/*", null);
    //static files handler        
    String staticDir = master.configuration.getStringProperty("serve-static", "swagger");
    context.setResourceBase(new File(master.getFile().getParent() + "/data/" + staticDir + "/").getAbsolutePath());
    context.addServlet(DefaultServlet.class, "/*");
    // serve resource files (images and so on)
    ServletHolder resHolder = new ServletHolder("static-home", DefaultServlet.class);
    resHolder.setInitParameter("resourceBase", Info.PATHS.PATH_RESOURCES_FOLDER.getAbsolutePath());
    resHolder.setInitParameter("dirAllowed", "true");
    resHolder.setInitParameter("pathInfoOnly", "true");
    context.addServlet(resHolder, "/res/*");
    HandlerList handlers = new HandlerList();
    handlers.addHandler(context);
    handlers.addHandler(new DefaultHandler());
    webServer.setHandler(handlers);
    webServer.start();
    LOG.info("Started RestAPI Server");
}

private Handler createAdminConsoleHandler() {
    FilterHolder filter = new FilterHolder(WicketFilter.class);
    filter.setInitParameter(ContextParamWebApplicationFactory.APP_CLASS_PARAM, HyracksAdminConsoleApplication.class.getName());
    filter.setInitParameter(WicketFilter.FILTER_MAPPING_PARAM, "/*");
    filter.setInitParameter(Application.CONFIGURATION, RuntimeConfigurationType.DEPLOYMENT.toString());
    ServletContextHandler handler = new ServletContextHandler(ServletContextHandler.SESSIONS);
    handler.setContextPath("/adminconsole");
    handler.setAttribute(ClusterControllerService.class.getName(), ccs);
    handler.addFilter(filter, "/*", EnumSet.of(DispatcherType.REQUEST, DispatcherType.ERROR));
    handler.addServlet(DefaultServlet.class, "/");
    return handler;
}

private Handler createAdminConsoleHandler() {
    FilterHolder filter = new FilterHolder(WicketFilter.class);
    filter.setInitParameter(ContextParamWebApplicationFactory.APP_CLASS_PARAM, HyracksAdminConsoleApplication.class.getName());
    filter.setInitParameter(WicketFilter.FILTER_MAPPING_PARAM, "/*");
    filter.setInitParameter(Application.CONFIGURATION, RuntimeConfigurationType.DEPLOYMENT.toString());
    ServletContextHandler handler = new ServletContextHandler(ServletContextHandler.SESSIONS);
    handler.setContextPath("/adminconsole");
    handler.setAttribute(ClusterControllerService.class.getName(), ccs);
    handler.addFilter(filter, "/*", EnumSet.of(DispatcherType.REQUEST, DispatcherType.ERROR));
    handler.addServlet(DefaultServlet.class, "/");
    return handler;
}

private Handler createAdminConsoleHandler() {
    FilterHolder filter = new FilterHolder(WicketFilter.class);
    filter.setInitParameter(ContextParamWebApplicationFactory.APP_CLASS_PARAM, HyracksAdminConsoleApplication.class.getName());
    filter.setInitParameter(WicketFilter.FILTER_MAPPING_PARAM, "/*");
    filter.setInitParameter(Application.CONFIGURATION, RuntimeConfigurationType.DEPLOYMENT.toString());
    ServletContextHandler handler = new ServletContextHandler(ServletContextHandler.SESSIONS);
    handler.setContextPath("/adminconsole");
    handler.setAttribute(ClusterControllerService.class.getName(), ccs);
    handler.addFilter(filter, "/*", EnumSet.of(DispatcherType.REQUEST, DispatcherType.ERROR));
    handler.addServlet(DefaultServlet.class, "/");
    return handler;
}

public static void main(String[] args) throws Exception {
    Map<String, Object> arguments = parse(args);
    int port = 8080;
    if (arguments.containsKey(PORT_ARG))
        port = (Integer) arguments.get(PORT_ARG);
    String resources = null;
    if (arguments.containsKey(RESOURCES_ARG))
        resources = (String) arguments.get(RESOURCES_ARG);
    TargetIdRetriever retriever = null;
    if (arguments.containsKey(RETRIEVER_ARG))
        retriever = (TargetIdRetriever) arguments.get(RETRIEVER_ARG);
    GatewayServer server = new GatewayServer();
    Connector connector = new SelectChannelConnector();
    connector.setPort(port);
    server.addConnector(connector);
    if (resources != null) {
        server.getContext().setResourceBase(resources);
        ServletHolder resourcesServletHolder = server.getContext().addServlet(DefaultServlet.class, "__r/*");
        resourcesServletHolder.setInitParameter("dirAllowed", "true");
    }
    if (retriever != null)
        server.setTargetIdRetriever(retriever);
    server.start();
}

private ServletContextHandler dumb(final String path) {
    final File srcGit = remoteRepository.getRepository().getDirectory();
    final URI base = srcGit.getParentFile().toURI();
    ServletContextHandler ctx = server.addContext(path);
    ctx.setResourceBase(base.toString());
    ServletHolder holder = ctx.addServlet(DefaultServlet.class, "/");
    // The tmp directory is symlinked on OS X
    holder.setInitParameter("aliases", "true");
    return ctx;
}

public static void main(final String[] args) throws Exception {
    System.setProperty("java.net.preferIPv4Stack", "true");
    System.setProperty("java.net.preferIPv6Addresses", "false");
    final Integer pairingCode = 7666;
    final Integer hostingPort = 4321;
    final String DB_NAME = "someDBName";
    final String name = "myName";
    final IClientSessionListener clientSessionListener = new IClientSessionListener() {

        @Override
        public void tearDownSession(final String server, final int port) {
        // TODO Auto-generated method stub
        }

        @Override
        public void registerNewSession(final Session session) throws Exception {
            // TODO Auto-generated method stub
            System.out.println("New session started: " + session);
        }
    };
    final Injector injector = Guice.createInjector(new JerseyServletModule() {

        @Override
        protected void configureServlets() {
            bind(String.class).annotatedWith(Names.named(Util.APPLICATION_NAME)).toInstance(name);
            bind(Integer.class).annotatedWith(Names.named(TouchRemoteResource.DACP_CLIENT_PAIRING_CODE)).toInstance(pairingCode);
            bind(Integer.class).annotatedWith(Names.named(TouchRemoteResource.DACP_CLIENT_PORT_NAME)).toInstance(hostingPort);
            bind(Integer.class).annotatedWith(Names.named(TouchAbleServerResource.DACP_SERVER_PORT_NAME)).toInstance(hostingPort);
            bind(Integer.class).annotatedWith(Names.named(UnpairedRemoteCrawler.SERVICE_PORT_NAME)).toInstance(hostingPort);
            bind(IZeroconfManager.class).toInstance(new ZeroconfManagerImpl());
            bind(String.class).annotatedWith(Names.named(PairingDatabase.NAME_OF_DB)).toInstance(DB_NAME);
            bind(IPairingDatabase.class).to(PairingDatabase.class).asEagerSingleton();
            bind(PairedRemoteDiscoverer.class).asEagerSingleton();
            //				bind(UnpairedRemoteCrawler.class).asEagerSingleton();
            bind(ITouchRemoteResource.class).to(TouchRemoteResource.class);
            bind(ITouchAbleServerResource.class).to(TouchAbleServerResource.class);
            bind(IClientSessionListener.class).toInstance(clientSessionListener);
            bind(SomeJerseyServlet.class).asEagerSingleton();
            bind(CustomByteArrayProvider.class);
            filter("*").through(ProxyFilter.class);
            serve("/*").with(GuiceContainer.class);
        }
    });
    final Server server = new Server(hostingPort);
    final Connector dmapConnector = new DmapConnector();
    dmapConnector.setPort(hostingPort);
    server.setConnectors(new Connector[] { dmapConnector });
    final ServletContextHandler sch = new ServletContextHandler(server, "/");
    sch.addEventListener(new GuiceServletContextListener() {

        @Override
        protected Injector getInjector() {
            return injector;
        }
    });
    sch.addFilter(GuiceFilter.class, "/*", EnumSet.of(DispatcherType.REQUEST));
    sch.addServlet(DefaultServlet.class, "/");
    server.start();
    System.out.println("");
}

@Override
public void initialize() throws LifecycleException {
    if (port < 0) {
        jetty = new Server();
    } else {
        jetty = new Server(port);
    }
    final ContextHandlerCollection contexts = new ContextHandlerCollection();
    jetty.setHandler(contexts);
    new ServletContextHandler(contexts, "/", ServletContextHandler.SESSIONS);
    final List<Handler> handlers = Lists.newArrayList();
    if (webapps.isEmpty()) {
        LOG.info("No programmatically added webapp to configure.");
    } else {
        for (Webapp webapp : webapps) {
            LOG.info("Adding webapp {}", webapp);
            final ServletContextHandler handler = new ServletContextHandler(contexts, webapp.getContext(), ServletContextHandler.SESSIONS);
            // add guice servlet filter
            // http://code.google.com/p/google-guice/wiki/ServletModule
            handler.addFilter(GuiceFilter.class, "/*", 0);
            handler.setResourceBase(webapp.getLocation());
            handler.addServlet(DefaultServlet.class, "/");
            handlers.add(handler);
        }
    }
    contexts.setHandlers(handlers.toArray(new Handler[handlers.size()]));
    // configure with jetty.xml
    if (config == null) {
        LOG.info("No configuration file given to load.");
    } else {
        try {
            LOG.info("Loading configuration {}", config);
            new XmlConfiguration(config).configure(jetty);
        /* CHECKSTYLE:OFF */
        } catch (Exception e) {
            throw new LifecycleException(e);
        }
    }
    try {
        jetty.start();
    /* CHECKSTYLE:OFF */
    } catch (Exception e) {
        throw new LifecycleException(e);
    }
}

@Override
public void startup(int port, String contextPath, String webRoot) throws EmbedServerException {
    this.port = port;
    Config config = Blade.$().config();
    int minThreads = config.getInt("server.jetty.min-threads", 8);
    int maxThreads = config.getInt("server.jetty.max-threads", 200);
    String poolName = config.get("server.jetty.pool-name", "blade-pool");
    // Setup Threadpool
    QueuedThreadPool threadPool = new QueuedThreadPool();
    threadPool.setMinThreads(minThreads);
    threadPool.setMaxThreads(maxThreads);
    threadPool.setName(poolName);
    this.server = new org.eclipse.jetty.server.Server(threadPool);
    this.webAppContext = new WebAppContext();
    this.webAppContext.setContextPath(contextPath);
    this.webAppContext.setResourceBase("");
    int securePort = config.getInt("server.jetty.http.secure-port", 9443);
    int outputBufferSize = config.getInt("server.jetty.http.output-buffersize", 32 * 1024);
    int requestHeaderSize = config.getInt("server.jetty.http.request-headersize", 8 * 1024);
    int responseHeaderSize = config.getInt("server.jetty.http.response-headersize", 8 * 1024);
    // HTTP Configuration
    HttpConfiguration http_config = new HttpConfiguration();
    http_config.setSecurePort(securePort);
    http_config.setOutputBufferSize(outputBufferSize);
    http_config.setRequestHeaderSize(requestHeaderSize);
    http_config.setResponseHeaderSize(responseHeaderSize);
    long idleTimeout = config.getLong("server.jetty.http.idle-timeout", 30000L);
    String host = config.get("server.host", "0.0.0.0");
    ServerConnector serverConnector = new ServerConnector(server, new HttpConnectionFactory(http_config));
    serverConnector.setHost(host);
    serverConnector.setPort(this.port);
    serverConnector.setIdleTimeout(idleTimeout);
    server.setConnectors(new Connector[] { serverConnector });
    boolean isAsync = config.getBoolean("server.async", false);
    Class<? extends Servlet> servlet = isAsync ? AsyncDispatcherServlet.class : DispatcherServlet.class;
    ServletHolder servletHolder = new ServletHolder(servlet);
    servletHolder.setAsyncSupported(isAsync);
    servletHolder.setInitOrder(1);
    webAppContext.addEventListener(new BladeInitListener());
    Set<String> statics = Blade.$().bConfig().getStatics();
    defaultHolder = new ServletHolder(DefaultServlet.class);
    defaultHolder.setInitOrder(0);
    if (StringKit.isNotBlank(classPath)) {
        LOGGER.info("add classpath : {}", classPath);
        defaultHolder.setInitParameter("resourceBase", classPath);
    }
    statics.forEach( s -> {
        if (s.indexOf(".") != -1) {
            webAppContext.addServlet(defaultHolder, s);
        } else {
            s = s.endsWith("/") ? s + '*' : s + "/*";
            webAppContext.addServlet(defaultHolder, s);
        }
    });
    webAppContext.addServlet(defaultHolder, "/favicon.ico");
    webAppContext.addServlet(servletHolder, "/");
    try {
        this.loadServlets(webAppContext);
        this.loadFilters(webAppContext);
        HandlerList handlerList = new HandlerList();
        handlerList.setHandlers(new Handler[] { webAppContext, new DefaultHandler() });
        server.setHandler(handlerList);
        server.setStopAtShutdown(true);
        server.start();
        LOGGER.info("Blade Server Listen on {}:{}", host, this.port);
        server.join();
    } catch (Exception e) {
        throw new EmbedServerException(e);
    }
}

@Override
public void run() {
    //mostly copied from http://www.eclipse.org/jetty/documentation/current/embedding-jetty.html
    // === jetty.xml ===
    // Setup Threadpool
    QueuedThreadPool threadPool = new QueuedThreadPool();
    threadPool.setMaxThreads(500);
    // Server
    this.server = new Server();
    // Extra options
    //server.setDumpAfterStart(true);
    //server.setDumpBeforeStop(true);
    server.setStopAtShutdown(true);
    //Handler Structure
    HandlerCollection handlers = new HandlerCollection();
    NCSARequestLog requestLog = new NCSARequestLog();
    requestLog.setFilename("request.log");
    requestLog.setFilenameDateFormat("yyyy_MM_dd");
    requestLog.setRetainDays(90);
    requestLog.setAppend(true);
    requestLog.setExtended(true);
    requestLog.setLogCookies(false);
    requestLog.setLogTimeZone("GMT");
    RequestLogHandler requestLogHandler = new RequestLogHandler();
    requestLogHandler.setRequestLog(requestLog);
    handlers.addHandler(requestLogHandler);
    // === jetty-https.xml ===
    // SSL Context Factory
    SslContextFactory sslContextFactory = new SslContextFactory();
    sslContextFactory.setKeyStore(keyStore);
    sslContextFactory.setKeyStorePassword(keyStorePassowrd);
    sslContextFactory.setKeyManagerPassword(keyStorePassowrd);
    sslContextFactory.setTrustStore(keyStore);
    sslContextFactory.setTrustStorePassword(keyStorePassowrd);
    //        sslContextFactory.setExcludeCipherSuites(
    //                "SSL_RSA_WITH_DES_CBC_SHA",
    //                "SSL_DHE_RSA_WITH_DES_CBC_SHA",
    //                "SSL_DHE_DSS_WITH_DES_CBC_SHA",
    //                "SSL_RSA_EXPORT_WITH_RC4_40_MD5",
    //                "SSL_RSA_EXPORT_WITH_DES40_CBC_SHA",
    //                "SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA",
    //                "SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA");
    // SSL HTTP Configuration     
    HttpConfiguration https_config = new HttpConfiguration();
    https_config.setSecureScheme("https");
    https_config.setSecurePort(port);
    https_config.setOutputBufferSize(32768);
    https_config.setRequestHeaderSize(8192);
    https_config.setResponseHeaderSize(8192);
    https_config.setSendServerVersion(true);
    https_config.setSendDateHeader(false);
    https_config.addCustomizer(new SecureRequestCustomizer());
    // SSL Connector
    ServerConnector sslConnector = new ServerConnector(server, new SslConnectionFactory(sslContextFactory, "http/1.1"), new HttpConnectionFactory(https_config));
    sslConnector.setPort(port);
    server.setConnectors(new Connector[] { sslConnector });
    // The WebAppContext is the entity that controls the environment in which a web application lives and
    // breathes. In this example the context path is being set to "/" so it is suitable for serving root context
    // requests and then we see it setting the location of the war. A whole host of other configurations are
    // available, ranging from configuring to support annotation scanning in the webapp (through
    // PlusConfiguration) to choosing where the webapp will unpack itself.
    //"capo/server/webapp","/");
    WebAppContext webapp = new WebAppContext();
    webapp.setContextPath("/");
    webapp.addServlet(WebResourcesServlet.class, "/wr/*");
    webapp.addServlet(DefaultServlet.class, "/public/*");
    webapp.addServlet(CapoWebWTServlet.class, "/*");
    webapp.setResourceBase(CapoApplication.getDataManager().getResourceDirectory(PREFERENCE.WEB_DIR.toString()).getResourceURI().getResourceURIString());
    webapp.getSessionHandler().getSessionManager().setMaxInactiveInterval(CapoApplication.getConfiguration().getIntValue(CapoServer.Preferences.WEB_SESSION_TIMEOUT));
    webapp.addEventListener(new ServletInit());
    // A WebAppContext is a ContextHandler as well so it needs to be set to the server so it is aware of where to
    // send the appropriate requests.       
    handlers.addHandler(webapp);
    try {
        server.setHandler(handlers);
        // Start the server
        server.start();
        server.join();
    } catch (Exception exception) {
        exception.printStackTrace();
    }
}

@Provides
@Singleton
private Server getServer(OptionalJettyConfig optionalConfig, Set<JettyConnectorProvider> jettyConnectors) {
    JettyConfig config = optionalConfig.getJettyConfig();
    Server server = new Server(config.getPort());
    Resource staticResourceBase = Resource.newClassPathResource(config.getStaticResourceBase());
    if (staticResourceBase != null) {
        // Set up a full web app since we have static content. We require the app to have its static content
        // under src/main/webapp and any other static resources that are packaged into jars are expected under
        // META-INF/resources.
        WebAppContext webAppContext = new WebAppContext();
        // We want to fail fast if we don't have any root resources defined or we have other issues starting up.
        webAppContext.setThrowUnavailableOnStartupException(true);
        webAppContext.addFilter(GuiceFilter.class, "/*", EnumSet.allOf(DispatcherType.class));
        webAppContext.addServlet(DefaultServlet.class, "/");
        webAppContext.setResourceBase(config.getWebAppResourceBase());
        webAppContext.setContextPath(config.getWebAppContextPath());
        webAppContext.setAttribute(WebInfConfiguration.CONTAINER_JAR_PATTERN, ".*\\.jar$");
        webAppContext.setConfigurations(new Configuration[] { new WebXmlConfiguration(), new WebInfConfiguration(), new MetaInfConfiguration(), new FragmentConfiguration() });
        server.setHandler(webAppContext);
    } else {
        // We don't have static content so just set up servlets.
        ServletContextHandler servletContextHandler = new ServletContextHandler(server, config.getWebAppContextPath(), ServletContextHandler.SESSIONS);
        servletContextHandler.addFilter(GuiceFilter.class, "/*", EnumSet.allOf(DispatcherType.class));
        servletContextHandler.addServlet(DefaultServlet.class, "/");
        servletContextHandler.setResourceBase(config.getWebAppResourceBase());
    }
    if (jettyConnectors != null) {
        for (JettyConnectorProvider connectorProvider : jettyConnectors) {
            server.addConnector(connectorProvider.getConnector(server));
        }
    }
    return server;
}

/**
     * Copied and modified from DefaultServlet.java.
     * Overridden to set the Locale for the dates.
     *
     * Get the resource list as a HTML directory listing.
     * @param base The base URL
     * @param parent True if the parent directory should be included
     * @return String of HTML
     */
@Override
protected void sendDirectory(HttpServletRequest request, HttpServletResponse response, Resource resource, String pathInContext) throws IOException {
    if (!_dirAllowed) {
        response.sendError(HttpServletResponse.SC_FORBIDDEN);
        return;
    }
    byte[] data = null;
    String base = URIUtil.addPaths(request.getRequestURI(), URIUtil.SLASH);
    //If the DefaultServlet has a resource base set, use it
    if (_resourceBase != null) {
        // handle ResourceCollection
        if (_resourceBase instanceof ResourceCollection)
            resource = _resourceBase.addPath(pathInContext);
    } else //Otherwise, try using the resource base of its enclosing context handler
    if (_contextHandler.getBaseResource() instanceof ResourceCollection)
        resource = _contextHandler.getBaseResource().addPath(pathInContext);
    String dir = getListHTML(resource, base, pathInContext.length() > 1);
    if (dir == null) {
        response.sendError(HttpServletResponse.SC_FORBIDDEN, "No directory");
        return;
    }
    data = dir.getBytes("UTF-8");
    response.setContentType("text/html; charset=UTF-8");
    response.setContentLength(data.length);
    response.getOutputStream().write(data);
}

private static WebAppContext setupWebAppContext(ZeppelinConfiguration conf) {
    WebAppContext webApp = new WebAppContext();
    webApp.setContextPath(conf.getServerContextPath());
    File warPath = new File(conf.getString(ConfVars.ZEPPELIN_WAR));
    if (warPath.isDirectory()) {
        // Development mode, read from FS
        // webApp.setDescriptor(warPath+"/WEB-INF/web.xml");
        webApp.setResourceBase(warPath.getPath());
        webApp.setParentLoaderPriority(true);
    } else {
        // use packaged WAR
        webApp.setWar(warPath.getAbsolutePath());
        File warTempDirectory = new File(conf.getRelativeDir(ConfVars.ZEPPELIN_WAR_TEMPDIR));
        warTempDirectory.mkdir();
        LOG.info("ZeppelinServer Webapp path: {}", warTempDirectory.getPath());
        webApp.setTempDirectory(warTempDirectory);
    }
    // Explicit bind to root
    webApp.addServlet(new ServletHolder(new DefaultServlet()), "/*");
    return webApp;
}

protected Server jettyRunTest(boolean tryPortRange) throws MojoExecutionException {
    JettyWebAppContext handler;
    try {
        handler = new JettyWebAppContext();
        handler.setWebInfLib(findJars());
        handler.setInitParameter("org.eclipse.jetty.servlet.Default.useFileMappedBuffer", "false");
        List<Resource> baseResources = new ArrayList<Resource>();
        baseResources.add(toResource(new File(outputDirectory, "META-INF/resources")));
        baseResources.add(toResource(testOutputDirectory));
        for (org.apache.maven.model.Resource r : testResources) {
            File testResourceDirectory = new File(r.getDirectory());
            if (testResourceDirectory.exists()) {
                baseResources.add(toResource(testResourceDirectory));
            }
        }
        handler.setBaseResource(new ResourceCollection(baseResources.toArray(new Resource[baseResources.size()])));
        getLog().info("Using base resources " + baseResources);
        ServletHolder servletHolder = new ServletHolder("default", DefaultServlet.class);
        servletHolder.setInitParameter("cacheControl", "no-store, no-cache, must-revalidate, max-age=0");
        handler.addServlet(servletHolder, "/");
        getLog().info("Set servlet cache control to 'do not cache'.");
    } catch (Exception e) {
        throw wrap(e);
    }
    return startJetty(handler, tryPortRange);
}

private void instantiateJettyWebServer() {
    String contextPathLocal;
    if (contextPath != null && contextPath.length() > 0) {
        if (!contextPath.startsWith("/")) {
            contextPathLocal = "/" + contextPath;
        } else {
            contextPathLocal = contextPath;
        }
    } else {
        contextPathLocal = "";
    }
    String servletPathLocal;
    if (servletPath != null && servletPath.length() > 0) {
        if (!servletPath.startsWith("/")) {
            servletPathLocal = "/" + servletPath;
        } else {
            servletPathLocal = servletPath;
        }
        if (servletPathLocal.endsWith("/")) {
            servletPathLocal += "*";
        } else {
            servletPathLocal += "/*";
        }
    } else {
        servletPathLocal = "/*";
    }
    ServletContextHandler context = new ServletContextHandler();
    context.setDisplayName("TestContext");
    context.setContextPath(contextPathLocal);
    if (servletClass != null) {
        ServletHolder holder = new ServletHolder(servletClass.getName(), servletClass);
        for (String initParamName : initParams.keySet()) {
            holder.setInitParameter(initParamName, initParams.get(initParamName));
        }
        context.addServlet(holder, servletPathLocal);
    } else {
        context.addServlet(DefaultServlet.class, servletPathLocal);
    // ServletHolder holder = new ServletHolder("default",
    // new HttpServlet() {
    // public void service() throws ServletException {
    // }
    // });
    // context.addServlet(holder, "");
    }
    for (Class<? extends EventListener> eventListener : eventListeners) {
        try {
            context.addEventListener(eventListener.newInstance());
        } catch (Exception e) {
            throw new TestContainerException(e);
        }
    }
    for (String contextParamName : contextParams.keySet()) {
        context.setInitParameter(contextParamName, contextParams.get(contextParamName));
    }
    // Filter support
    if (filters != null) {
        for (WebAppDescriptor.FilterDescriptor d : this.filters) {
            FilterHolder fh = new FilterHolder(d.getFilterClass());
            fh.setName(d.getFilterName());
            if (d.getInitParams() != null) {
                fh.setInitParameters(d.getInitParams());
            }
            context.addFilter(fh, servletPathLocal, null);
        }
    }
    try {
        final String host = (baseUri.getHost() == null) ? "0.0.0.0" : baseUri.getHost();
        final int port = (baseUri.getPort() == -1) ? 80 : baseUri.getPort();
        server = new Server(new InetSocketAddress(host, port));
        server.setHandler(context);
    } catch (Exception ioe) {
        throw new TestContainerException(ioe);
    }
}

@Override
public void start() throws KairosDBException {
    try {
        if (m_port > 0)
            m_server = new Server(new InetSocketAddress(m_address, m_port));
        else
            m_server = new Server();
        if (m_pool != null)
            m_server.setThreadPool(m_pool);
        //Set up SSL
        if (m_keyStorePath != null && !m_keyStorePath.isEmpty()) {
            logger.info("Using SSL");
            SslContextFactory sslContextFactory = new SslContextFactory(m_keyStorePath);
            if (m_cipherSuites != null && m_cipherSuites.length > 0)
                sslContextFactory.setIncludeCipherSuites(m_cipherSuites);
            if (m_protocols != null && m_protocols.length > 0)
                sslContextFactory.setIncludeProtocols(m_protocols);
            sslContextFactory.setKeyStorePassword(m_keyStorePassword);
            SslSelectChannelConnector selectChannelConnector = new SslSelectChannelConnector(sslContextFactory);
            selectChannelConnector.setPort(m_sslPort);
            m_server.addConnector(selectChannelConnector);
        }
        ServletContextHandler servletContextHandler = new ServletContextHandler();
        //Turn on basic auth if the user was specified
        if (m_authUser != null) {
            servletContextHandler.setSecurityHandler(basicAuth(m_authUser, m_authPassword, "kairos"));
            servletContextHandler.setContextPath("/");
        }
        servletContextHandler.addFilter(GuiceFilter.class, "/api/*", null);
        servletContextHandler.addServlet(DefaultServlet.class, "/api/*");
        ResourceHandler resourceHandler = new ResourceHandler();
        resourceHandler.setDirectoriesListed(true);
        resourceHandler.setWelcomeFiles(new String[] { "index.html" });
        resourceHandler.setResourceBase(m_webRoot);
        resourceHandler.setAliases(true);
        HandlerList handlers = new HandlerList();
        handlers.setHandlers(new Handler[] { servletContextHandler, resourceHandler, new DefaultHandler() });
        m_server.setHandler(handlers);
        m_server.start();
    } catch (Exception e) {
        throw new KairosDBException(e);
    }
}

private ServletContextHandler createServletContextHandler(final String resourceBase, final Iterable<EventListener> eventListeners, final Map<FilterHolder, String> filterHolders) {
    final ServletContextHandler context = new ServletContextHandler(server, "/", ServletContextHandler.NO_SESSIONS);
    context.setContextPath("/");
    if (resourceBase != null) {
        // Required if you want a webapp directory. See ContextHandler#getResource and http://docs.codehaus.org/display/JETTY/Embedding+Jetty
        final String webapp = this.getClass().getClassLoader().getResource(resourceBase).toExternalForm();
        context.setResourceBase(webapp);
    }
    // Jersey insists on using java.util.logging (JUL)
    final EventListener listener = new JULServletContextListener();
    context.addEventListener(listener);
    for (final EventListener eventListener : eventListeners) {
        context.addEventListener(eventListener);
    }
    for (final FilterHolder filterHolder : filterHolders.keySet()) {
        context.addFilter(filterHolder, filterHolders.get(filterHolder), EnumSet.of(DispatcherType.REQUEST, DispatcherType.ASYNC));
    }
    // Make sure Guice filter all requests
    final FilterHolder filterHolder = new FilterHolder(GuiceFilter.class);
    context.addFilter(filterHolder, "/*", EnumSet.of(DispatcherType.REQUEST, DispatcherType.ASYNC));
    // Backend servlet for Guice - never used
    final ServletHolder sh = new ServletHolder(DefaultServlet.class);
    context.addServlet(sh, "/*");
    return context;
}

/**
     * @param args
     */
public static void main(String[] args) {
    try {
        if (args.length < 2) {
            System.out.println("Image 出力サンプルサー�");
            System.out.println();
            System.out.println("USAGE A : WSImageServletTest [-p <port>] (duration) (jpg) (jpg) ...");
            System.out.println("USAGE B : WSImageServletTest [-p <port>] (duration) (lst)");
            System.out.println("port     : �ート番�");
            System.out.println("duration : フレーム間隔 (ms)");
            System.out.println("jpg      : �出�るJPEGファイル 複数指定時�先頭�ら順��出�れる");
            System.out.println("lst      : �出�るJPEGファイル�リスト");
            System.exit(-1);
        }
        // デフォルト値
        int webport = DEFAULT_WEBPORT;
        String wspath = DEFAULT_WSPATH;
        // プロパティファイル読�込�
        File f = new File(PROPERTY_FILE);
        if (f.exists() && f.isFile()) {
            System.out.println("Load from property file. : " + PROPERTY_FILE);
            // Try to read property file.
            Properties serverprop = new Properties();
            Reader freader = null;
            try {
                freader = new FileReader(PROPERTY_FILE);
                serverprop.load(freader);
                // may
                if (serverprop.containsKey("port")) {
                    webport = Integer.parseInt(serverprop.getProperty("port"));
                }
                // may
                if (serverprop.containsKey("path")) {
                    wspath = serverprop.getProperty("path");
                }
            } catch (IOException e) {
                System.out.println("IO error at reading property file. : " + PROPERTY_FILE);
                System.exit(-1);
            } finally {
                if (freader != null)
                    freader.close();
            }
        }
        int arg_index = 0;
        // �ート指定
        if (args[0].toLowerCase().equals("-p")) {
            webport = Integer.parseInt(args[1]);
            arg_index = 2;
        }
        final int duration = Integer.parseInt(args[arg_index]);
        arg_index++;
        // 読�込むファイルリスト�作�
        List<String> files = new ArrayList<String>();
        if (args[arg_index].toLowerCase().endsWith("jpg") || args[arg_index].toLowerCase().endsWith("jpeg")) {
            for (; arg_index < args.length; arg_index++) {
                files.add(args[arg_index]);
            }
        } else {
            try {
                FileReader fr = new FileReader(args[arg_index]);
                BufferedReader reader = new BufferedReader(fr);
                String line = null;
                while ((line = reader.readLine()) != null) {
                    files.add(line.trim());
                }
                reader.close();
                fr.close();
            } catch (IOException e) {
                System.out.println("Following IOException occurred. Ignore this file.");
                e.printStackTrace();
                System.exit(-1);
            }
        }
        // 画�ファイル�読�込�
        final List<byte[]> frames = new ArrayList<byte[]>(files.size());
        List<String> loaded_files = new ArrayList<String>(files.size());
        for (String file : files) {
            System.out.print("Loading " + file + " ... ");
            try {
                FileInputStream fi = new FileInputStream(file);
                ByteArrayOutputStream bo = new ByteArrayOutputStream();
                int ch = 0;
                while ((ch = fi.read()) != -1) {
                    bo.write(ch);
                }
                fi.close();
                bo.close();
                byte[] frame = bo.toByteArray();
                if (// SOI
                frame[0] == (byte) 0xff && frame[1] == (byte) 0xd8 && frame[frame.length - 2] == (byte) 0xff && frame[frame.length - 1] == (byte) 0xd9) {
                    // EOI
                    frames.add(frame);
                    loaded_files.add(file);
                    System.out.println("OK");
                } else {
                    System.out.println("Invalid JPEG file format. Ignore this file.");
                }
            } catch (IOException e) {
                System.out.println("Following IOException occurred. Ignore this file.");
                e.printStackTrace();
            }
        }
        if (loaded_files.size() == 0) {
            System.out.println("No avaleble JPEG.");
            System.exit(-1);
        }
        System.out.println("Duration (ms) : " + duration);
        System.out.println("JPEG frames   :");
        int i = 0;
        for (String file : loaded_files) {
            System.out.printf(" %2d %s%n", i, file);
            i++;
        }
        // init Jetty
        Server server = new Server(webport);
        server.setStopAtShutdown(true);
        ServletContextHandler root = new ServletContextHandler(server, "/", ServletContextHandler.SESSIONS);
        // set default web servlet and document root.
        root.setResourceBase("./");
        root.setInitParameter("org.eclipse.jetty.servlet.Default.dirAllowed", "false");
        root.addServlet(DefaultServlet.class, "/*");
        // MJPEG�セットアップ
        final WSImageServlet servlet = new WSImageServlet();
        ServletHolder wsh = new ServletHolder(servlet);
        root.addServlet(wsh, wspath);
        // set callback when receive JPEG frame
        Thread t = new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    int frame = 0;
                    long next_time = System.currentTimeMillis() + duration;
                    while (true) {
                        // Servlet ��フレーム��り出�れる��ブロック
                        servlet.pourFrame(frames.get(frame));
                        long now = System.currentTimeMillis();
                        frame++;
                        if (frames.size() == frame) {
                            frame = 0;
                        }
                        if (now < next_time) {
                            // 次フレーム開始時刻��待機
                            Thread.sleep(next_time - now);
                            // 次々フレーム開始時刻
                            next_time += duration;
                        } else {
                            // �延����ウエイト無��次フレーム
                            while (next_time < now) {
                                next_time += duration;
                            }
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.setDaemon(true);
        t.start();
        // Jettyサー�起動
        server.start();
        System.out.println("Start web server at port : " + webport);
        System.out.println("WebSocket path           : " + wspath);
        // コマンド入力待�
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        while (true) {
            System.out.print("Input Command >");
            String line = reader.readLine();
            // �ックグラウンド動作対策
            if (line == null) {
                Thread.sleep(1000);
                continue;
            }
            if ("".equals(line.trim()))
                continue;
            String[] cmds = line.split("\\s+");
            if ("bye".equals(cmds[0])) {
                // bye : 終了
                break;
            }
        }
        if (server != null) {
            // Jettyサー��止
            server.stop();
            server.join();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

@Override
public void start(FolderContext music, FolderContext mount, int port, String user, String password) throws Exception {
    ServletContextHandler mountContext = new ServletContextHandler(ServletContextHandler.NO_SESSIONS);
    mountContext.setContextPath(mount.getPath());
    mountContext.setSecurityHandler(user == null ? null : basicAuthentication("MusicMount", user, password));
    mountContext.setBaseResource(Resource.newResource(mount.getFolder()));
    mountContext.setWelcomeFiles(new String[] { "index.json" });
    MimeTypes mountTypes = new MimeTypes();
    mountTypes.addMimeMapping("json", MimeTypes.TEXT_JSON_UTF_8);
    mountContext.setMimeTypes(mountTypes);
    ServletHolder mountServlet = new ServletHolder(new DefaultServlet());
    mountServlet.setInitParameter("dirAllowed", "false");
    mountContext.addServlet(mountServlet, "/*");
    ServletContextHandler musicContext = new ServletContextHandler(ServletContextHandler.NO_SESSIONS);
    musicContext.setContextPath(music.getPath());
    musicContext.setSecurityHandler(user == null ? null : basicAuthentication("MusicMount", user, password));
    musicContext.setBaseResource(Resource.newResource(music.getFolder()));
    MimeTypes musicTypes = new MimeTypes();
    musicTypes.addMimeMapping("m4a", "audio/mp4");
    musicTypes.addMimeMapping("mp3", "audio/mpeg");
    musicContext.setMimeTypes(musicTypes);
    ServletHolder musicServlet = new ServletHolder(new DefaultServlet());
    musicServlet.setInitParameter("dirAllowed", "false");
    musicContext.addServlet(musicServlet, "/*");
    GzipHandler gzipMountContext = new GzipHandler();
    gzipMountContext.setMimeTypes(MimeTypes.TEXT_JSON);
    gzipMountContext.setHandler(mountContext);
    ContextHandlerCollection contexHandlers = new ContextHandlerCollection();
    contexHandlers.setHandlers(new Handler[] { gzipMountContext, musicContext });
    RequestLogHandler requestLogHandler = new RequestLogHandler();
    requestLogHandler.setRequestLog(new ConsoleRequestLog());
    HandlerCollection handlers = new HandlerCollection();
    handlers.setHandlers(new Handler[] { contexHandlers, new DefaultHandler(), requestLogHandler });
    server = new Server(port);
    server.setHandler(handlers);
    server.setGracefulShutdown(1000);
    server.setStopAtShutdown(true);
    server.start();
}

@SuppressWarnings({ "unchecked", "rawtypes" })
private void deployWebContexts() {
    List<ContextWebServer> webContexts = getWebContexts();
    Handler[] handlers = new Handler[webContexts.size()];
    int i = 0;
    for (ContextWebServer contextWebServer : webContexts) {
        ServletContextHandler handler;
        if (contextWebServer.getResources() != null) {
            handler = new WebAppContext(contextWebServer.getResources(), contextWebServer.getContext());
        } else {
            handler = new ServletContextHandler(null, contextWebServer.getContext(), ServletContextHandler.SESSIONS | ServletContextHandler.SECURITY);
            handler.addServlet(DefaultServlet.class, "/*");
        }
        handler.setAttribute(WebInfConfiguration.CONTAINER_JAR_PATTERN, ".*/.*jsp-api-[^/]*\\.jar$|.*/.*jsp-[^/]*\\.jar$|.*/.*taglibs[^/]*\\.jar$|.*/.*jstl[^/]*\\.jar$|.*/.*jsf-impl-[^/]*\\.jar$|.*/.*javax.faces-[^/]*\\.jar$|.*/.*myfaces-impl-[^/]*\\.jar$");
        // performRemoveTagLibConfiguration((WebAppContext) handler);
        Set<Entry<String, Object>> attrs = contextWebServer.getAttributes().entrySet();
        for (Entry<String, Object> entry : attrs) {
            handler.setAttribute(entry.getKey(), entry.getValue());
        }
        Set<Entry<String, String>> params = contextWebServer.getInitParameters().entrySet();
        for (Entry<String, String> entry : params) {
            handler.setInitParameter(entry.getKey(), entry.getValue());
        }
        configWindows(handler);
        List<Object> listeners = contextWebServer.getListeners();
        for (Object listener : listeners) {
            if (listener instanceof String) {
                listener = ReflectUtil.classForName((String) listener);
            }
            if (listener instanceof Class) {
                listener = ReflectUtil.newInstance((Class) listener);
            }
            handler.addEventListener((EventListener) listener);
        }
        List<FilterDesc> filters = contextWebServer.getFilters();
        for (FilterDesc desc : filters) {
            Object filter = desc.getFilter();
            if (filter instanceof Filter) {
                FilterHolder holder = new FilterHolder((Filter) filter);
                handler.addFilter(holder, desc.getPath(), EnumSet.of(DispatcherType.REQUEST));
            } else if (filter instanceof FilterHolder) {
                handler.addFilter((FilterHolder) filter, desc.getPath(), EnumSet.of(DispatcherType.REQUEST));
            } else if (filter instanceof Class) {
                handler.addFilter((Class) filter, desc.getPath(), EnumSet.of(DispatcherType.REQUEST));
            } else {
                handler.addFilter((String) filter, desc.getPath(), EnumSet.of(DispatcherType.REQUEST));
            }
        }
        List<ServletDesc> servlets = contextWebServer.getServlets();
        for (ServletDesc desc : servlets) {
            Object servlet = desc.getServlet();
            if (servlet instanceof HttpServlet) {
                ServletHolder holder = new ServletHolder((HttpServlet) servlet);
                handler.addServlet(holder, desc.getPath());
            } else if (servlet instanceof ServletHolder) {
                handler.addServlet((ServletHolder) servlet, desc.getPath());
            } else if (servlet instanceof Class) {
                handler.addServlet((Class) servlet, desc.getPath());
            } else {
                handler.addServlet((String) servlet, desc.getPath());
            }
        }
        for (Decorator decorator : decorators) {
            handler.addDecorator(decorator);
        }
        handlers[i++] = handler;
    }
    ContextHandlerCollection contexts = new ContextHandlerCollection();
    contexts.setHandlers(handlers);
    server.setHandler(contexts);
}

@BeforeClass
public static void start() throws Exception {
    ServletContextHandler context = new ServletContextHandler(ServletContextHandler.NO_SESSIONS);
    context.setContextPath("/");
    /*
        ServletHolder jerseyServlet = context.addServlet(org.glassfish.jersey.servlet.ServletContainer.class, "/api/*"); // XXX maybe move the static resources to something other than /*  so i can put this at /* ?
        jerseyServlet.setInitOrder(1);
        jerseyServlet.setInitParameter(ServerProperties.APPLICATION_NAME, "mtwilson-api-v2"); // constant, might be seen if monitoring the server with JMX and useful for identifying threads of two or more applications running in the same container
        jerseyServlet.setInitParameter(ServerProperties.PROVIDER_PACKAGES, "com.intel.mtwilson.ws.jersey,com.intel.mtwilson.ws.jersey.util,com.fasterxml.jackson.jaxrs.json,com.fasterxml.jackson.jaxrs.xml"); // XXX package names would come from plugin components and would be combined to form this property ... providers and resources found in these packages are ADDED to what is returned by getClasses() in the JerseyApplication instance 
        jerseyServlet.setInitParameter(ServerProperties.MEDIA_TYPE_MAPPINGS, "txt:text/plain, xml:application/xml, json:application/json, html:text/html"); // XXX need to combine mappings nominated by each plugin component , and have a rule about how to handle conflicts, or have this be an item that is controlled in central configuration where plugins can propose changes and administrator can resolve conflicts and save whatever they want here
        jerseyServlet.setInitParameter(ServerProperties.LANGUAGE_MAPPINGS, "en:en, fr:fr"); // XXX this one is more standard so we can simply convert an exsiting language code list to this format,  where the extension is the language code,  and optionally support some country codes too like .en_US -> en-US  


        // optional static content
        ServletHolder staticServlet = context.addServlet(DefaultServlet.class, "/*");
        staticServlet.setInitParameter("resourceBase", "src/main/resources/html5");
        staticServlet.setInitParameter("pathInfoOnly", "true");
*/
    ServletContainer jerseyServletContainer = new org.glassfish.jersey.servlet.ServletContainer();
    // XXX maybe move the static resources to something other than /*  so i can put this at /* ?
    ServletHolder jerseyServletHolder = new ServletHolder(jerseyServletContainer);
    jerseyServletHolder.setInitOrder(1);
    // constant, might be seen if monitoring the server with JMX and useful for identifying threads of two or more applications running in the same container
    jerseyServletHolder.setInitParameter(ServerProperties.APPLICATION_NAME, "mtwilson-api-v2");
    // XXX package names would come from plugin components and would be combined to form this property ... providers and resources found in these packages are ADDED to what is returned by getClasses() in the JerseyApplication instance 
    jerseyServletHolder.setInitParameter(ServerProperties.PROVIDER_PACKAGES, "com.intel.mtwilson.ws.jersey,com.intel.mtwilson.ws.jersey.util,com.fasterxml.jackson.jaxrs.json,com.fasterxml.jackson.jaxrs.xml");
    // XXX need to combine mappings nominated by each plugin component , and have a rule about how to handle conflicts, or have this be an item that is controlled in central configuration where plugins can propose changes and administrator can resolve conflicts and save whatever they want here;   NOTE: using text/yaml and not application/yaml as the default mapping for .yaml because browsers display text/yaml and try to download as a file application/yaml
    jerseyServletHolder.setInitParameter(ServerProperties.MEDIA_TYPE_MAPPINGS, "txt:text/plain, xml:application/xml, json:application/json, html:text/html, saml:application/saml+xml, bin:application/octet-stream, yaml:text/yaml");
    // XXX this one is more standard so we can simply convert an exsiting language code list to this format,  where the extension is the language code,  and optionally support some country codes too like .en_US -> en-US  
    jerseyServletHolder.setInitParameter(ServerProperties.LANGUAGE_MAPPINGS, "en:en, fr:fr");
    context.addServlet(jerseyServletHolder, "/api/v2/*");
    // optional static content
    ServletHolder staticServletHolder = new ServletHolder(new DefaultServlet());
    staticServletHolder.setInitParameter("resourceBase", "src/main/resources/html5");
    staticServletHolder.setInitParameter("pathInfoOnly", "true");
    context.addServlet(staticServletHolder, "/*");
    server.setHandler(context);
    server.start();
/*
        ServletHandler handler = new ServletHandler();
//        handler.set
        
        ContextHandler context = new ContextHandler();
        context.setContextPath("/");
        context.setResourceBase(".");
        context.setClassLoader(Thread.currentThread().getContextClassLoader()); // XXX TODO for plugin arch this is important to get the right classloader for the module...
//        context.setHandler(new HelloHandler());
//        server.setHandler(context);  
* */
}

public static void main(String[] args) throws Exception {
    Options options = new Options();
    options.addOption("homeDir", true, "Home directory for the service");
    CommandLineParser parser = new GnuParser();
    CommandLine cmd = parser.parse(options, args);
    Properties configProps = new Properties();
    String homeDir = cmd.getOptionValue("homeDir");
    if (homeDir.endsWith("/")) {
        homeDir = homeDir.substring(0, homeDir.length() - 1);
    }
    DOMConfigurator.configure(homeDir + "/log4j.xml");
    logger.warn("DataServices Server starting...");
    File configFile = new File(homeDir + "/config.properties");
    FileReader configFileReader = new FileReader(configFile);
    try {
        configProps.load(configFileReader);
        Option[] cmdOptions = cmd.getOptions();
        for (Option opt : cmdOptions) {
            String argName = opt.getOpt();
            String argValue = opt.getValue();
            configProps.put(argName, argValue);
        }
    } finally {
        if (configFileReader != null) {
            configFileReader.close();
        }
    }
    WebAppContext context = new WebAppContext();
    Injector injector = Guice.createInjector(new DefaultServletModule(configProps), new AlertsServerModule(configProps), new DefaultShiroWebModule(configProps, context.getServletContext()), new AbstractModule() {

        @Override
        protected void configure() {
            binder().requireExplicitBindings();
            bind(GuiceFilter.class);
            bind(GuiceResteasyBootstrapServletContextListener.class);
            bind(EnvironmentLoaderListener.class);
        }
    });
    injector.getAllBindings();
    injector.createChildInjector().getAllBindings();
    Server server = new Server(port);
    /***************************************************
         *************** enable SSL ************************
         ***************************************************/
    // HTTP Configuration
    HttpConfiguration http_config = new HttpConfiguration();
    http_config.setSecureScheme("https");
    http_config.setSecurePort(8443);
    http_config.setOutputBufferSize(32768);
    http_config.setRequestHeaderSize(8192);
    http_config.setResponseHeaderSize(8192);
    http_config.setSendServerVersion(true);
    http_config.setSendDateHeader(false);
    // httpConfig.addCustomizer(new ForwardedRequestCustomizer())
    // SSL Context Factory
    SslContextFactory sslContextFactory = new SslContextFactory();
    String sslKeystorePath = configProps.getProperty("sslKeystorePath", "/keystore");
    logger.debug("sslKeystorePath: " + sslKeystorePath);
    sslContextFactory.setKeyStorePath(homeDir + sslKeystorePath);
    String sslKeystorePassword = configProps.getProperty("sslKeystorePassword");
    sslContextFactory.setKeyStorePassword(sslKeystorePassword);
    String sslKeyManagerPassword = configProps.getProperty("sslKeyManagerPassword");
    if (sslKeyManagerPassword != null && !sslKeyManagerPassword.isEmpty()) {
        sslContextFactory.setKeyManagerPassword(sslKeyManagerPassword);
    }
    String sslTruststorePath = configProps.getProperty("sslTruststorePath");
    if (sslTruststorePath != null && !sslTruststorePath.isEmpty()) {
        sslContextFactory.setTrustStorePath(homeDir + sslTruststorePath);
    }
    String sslTruststorePassword = configProps.getProperty("sslTruststorePassword");
    if (sslTruststorePassword != null && !sslTruststorePassword.isEmpty()) {
        sslContextFactory.setTrustStorePassword(sslTruststorePassword);
    }
    sslContextFactory.setExcludeCipherSuites("SSL_RSA_WITH_DES_CBC_SHA", "SSL_DHE_RSA_WITH_DES_CBC_SHA", "SSL_DHE_DSS_WITH_DES_CBC_SHA", "SSL_RSA_EXPORT_WITH_RC4_40_MD5", "SSL_RSA_EXPORT_WITH_DES40_CBC_SHA", "SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA", "SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA");
    // SSL HTTP Configuration
    HttpConfiguration https_config = new HttpConfiguration(http_config);
    https_config.addCustomizer(new SecureRequestCustomizer());
    // SSL Connector
    ServerConnector sslConnector = new ServerConnector(server, new SslConnectionFactory(sslContextFactory, "http/1.1"), new HttpConnectionFactory(https_config));
    sslConnector.setPort(8443);
    server.addConnector(sslConnector);
    FilterHolder guiceFilter = new FilterHolder(injector.getInstance(GuiceFilter.class));
    /** For JSP support.  Used only for testing and debugging for now.  This came come out
         * once the real consumers for this service are in place
         */
    URL indexUri = Main.class.getResource(WEBROOT_INDEX);
    if (indexUri == null) {
        throw new FileNotFoundException("Unable to find resource " + WEBROOT_INDEX);
    }
    // Points to wherever /webroot/ (the resource) is
    URI baseUri = indexUri.toURI();
    // Establish Scratch directory for the servlet context (used by JSP compilation)
    File tempDir = new File(System.getProperty("java.io.tmpdir"));
    File scratchDir = new File(tempDir.toString(), "embedded-jetty-jsp");
    if (!scratchDir.exists()) {
        if (!scratchDir.mkdirs()) {
            throw new IOException("Unable to create scratch directory: " + scratchDir);
        }
    }
    // Set JSP to use Standard JavaC always
    System.setProperty("org.apache.jasper.compiler.disablejsr199", "false");
    context.setAttribute("javax.servlet.context.tempdir", scratchDir);
    context.setAttribute(InstanceManager.class.getName(), new SimpleInstanceManager());
    //Ensure the jsp engine is initialized correctly
    JettyJasperInitializer sci = new JettyJasperInitializer();
    ServletContainerInitializersStarter sciStarter = new ServletContainerInitializersStarter(context);
    ContainerInitializer initializer = new ContainerInitializer(sci, null);
    List<ContainerInitializer> initializers = new ArrayList<ContainerInitializer>();
    initializers.add(initializer);
    context.setAttribute("org.eclipse.jetty.containerInitializers", initializers);
    context.addBean(sciStarter, true);
    // Set Classloader of Context to be sane (needed for JSTL)
    // JSP requires a non-System classloader, this simply wraps the
    // embedded System classloader in a way that makes it suitable
    // for JSP to use
    // new URL( "file:///home/prhodes/.m2/repository/javax/servlet/jsp/javax.servlet.jsp-api/2.3.1/javax.servlet.jsp-api-2.3.1.jar" ) 
    ClassLoader jspClassLoader = new URLClassLoader(new URL[] {}, Thread.currentThread().getContextClassLoader());
    context.setClassLoader(jspClassLoader);
    // Add JSP Servlet (must be named "jsp")
    ServletHolder holderJsp = new ServletHolder("jsp", JspServlet.class);
    holderJsp.setInitOrder(0);
    holderJsp.setInitParameter("logVerbosityLevel", "DEBUG");
    holderJsp.setInitParameter("fork", "false");
    holderJsp.setInitParameter("xpoweredBy", "false");
    holderJsp.setInitParameter("compilerTargetVM", "1.7");
    holderJsp.setInitParameter("compilerSourceVM", "1.7");
    holderJsp.setInitParameter("keepgenerated", "true");
    context.addServlet(holderJsp, "*.jsp");
    //context.addServlet(holderJsp,"*.jspf");
    //context.addServlet(holderJsp,"*.jspx");
    // Add Default Servlet (must be named "default")
    ServletHolder holderDefault = new ServletHolder("default", DefaultServlet.class);
    holderDefault.setInitParameter("resourceBase", baseUri.toASCIIString());
    holderDefault.setInitParameter("dirAllowed", "true");
    context.addServlet(holderDefault, "/");
    /** end "for JSP support */
    context.setResourceBase(baseUri.toASCIIString());
    context.setInitParameter("resteasy.guice.modules", "com.opensoc.dataservices.modules.guice.RestEasyModule");
    context.setInitParameter("resteasy.servlet.mapping.prefix", "/rest");
    context.addEventListener(injector.getInstance(GuiceResteasyBootstrapServletContextListener.class));
    context.addFilter(guiceFilter, "/*", EnumSet.allOf(DispatcherType.class));
    server.setHandler(context);
    server.start();
    AlertsProcessingServer alertsServer = injector.getInstance(AlertsProcessingServer.class);
    alertsServer.startProcessing();
    server.join();
}

//CHECKSTYLE:OFF
@Test
public void testHandler() throws Exception {
    ServerModel serverModel = new ServerModel();
    JettyServerImpl server = new JettyServerImpl(serverModel, null);
    server.start();
    TestListener listener = new TestListener();
    JettyServerWrapper container = server.getServer();
    container.addBean(listener);
    WebContainerContext httpContext = new WebContainerContext() {

        @Override
        public Set<String> getResourcePaths(String name) {
            return Collections.emptySet();
        }

        @Override
        public String getContextId() {
            return "test";
        }

        public boolean handleSecurity(HttpServletRequest request, HttpServletResponse response) throws IOException {
            return false;
        }

        public URL getResource(String name) {
            return null;
        }

        public String getMimeType(String name) {
            return null;
        }
    };
    Bundle testBundle = new Bundle() {

        @Override
        public int compareTo(Bundle arg0) {
            return 0;
        }

        @Override
        public int getState() {
            return 0;
        }

        @Override
        public void start(int options) throws BundleException {
        }

        @Override
        public void start() throws BundleException {
        }

        @Override
        public void stop(int options) throws BundleException {
        }

        @Override
        public void stop() throws BundleException {
        }

        @Override
        public void update(InputStream input) throws BundleException {
        }

        @Override
        public void update() throws BundleException {
        }

        @Override
        public void uninstall() throws BundleException {
        }

        @Override
        public Dictionary<String, String> getHeaders() {
            Dictionary<String, String> dict = new Hashtable<>();
            dict.put(Constants.BUNDLE_VERSION, "1.0.0");
            return dict;
        }

        @Override
        public long getBundleId() {
            return 0;
        }

        @Override
        public String getLocation() {
            return null;
        }

        @Override
        public ServiceReference<?>[] getRegisteredServices() {
            return null;
        }

        @Override
        public ServiceReference<?>[] getServicesInUse() {
            return null;
        }

        @Override
        public boolean hasPermission(Object permission) {
            return false;
        }

        @Override
        public URL getResource(String name) {
            return null;
        }

        @Override
        public Dictionary<String, String> getHeaders(String locale) {
            return null;
        }

        @Override
        public String getSymbolicName() {
            return "HandlerDestructorTest-SymbolicNameBundle";
        }

        @Override
        public Class<?> loadClass(String name) throws ClassNotFoundException {
            return null;
        }

        @Override
        public Enumeration<URL> getResources(String name) throws IOException {
            return null;
        }

        @Override
        public Enumeration<String> getEntryPaths(String path) {
            return null;
        }

        @Override
        public URL getEntry(String path) {
            return null;
        }

        @Override
        public long getLastModified() {
            return 0;
        }

        @Override
        public Enumeration<URL> findEntries(String path, String filePattern, boolean recurse) {
            return null;
        }

        @Override
        public BundleContext getBundleContext() {
            return new BundleContext() {

                @Override
                public boolean ungetService(ServiceReference<?> reference) {
                    return false;
                }

                @Override
                public void removeServiceListener(ServiceListener listener) {
                }

                @Override
                public void removeFrameworkListener(FrameworkListener listener) {
                }

                @Override
                public void removeBundleListener(BundleListener listener) {
                }

                @Override
                public <S> ServiceRegistration<S> registerService(Class<S> clazz, S service, Dictionary<String, ?> properties) {
                    return null;
                }

                @Override
                public ServiceRegistration<?> registerService(String clazz, Object service, Dictionary<String, ?> properties) {
                    return null;
                }

                @Override
                public ServiceRegistration<?> registerService(String[] clazzes, Object service, Dictionary<String, ?> properties) {
                    return null;
                }

                @Override
                public Bundle installBundle(String location, InputStream input) throws BundleException {
                    return null;
                }

                @Override
                public Bundle installBundle(String location) throws BundleException {
                    return null;
                }

                @Override
                public <S> Collection<ServiceReference<S>> getServiceReferences(Class<S> clazz, String filter) throws InvalidSyntaxException {
                    return null;
                }

                @Override
                public ServiceReference<?>[] getServiceReferences(String clazz, String filter) throws InvalidSyntaxException {
                    return null;
                }

                @Override
                public <S> ServiceReference<S> getServiceReference(Class<S> clazz) {
                    return null;
                }

                @Override
                public ServiceReference<?> getServiceReference(String clazz) {
                    return null;
                }

                @Override
                public <S> S getService(ServiceReference<S> reference) {
                    return null;
                }

                @Override
                public String getProperty(String key) {
                    return null;
                }

                @Override
                public File getDataFile(String filename) {
                    return null;
                }

                @Override
                public Bundle[] getBundles() {
                    return null;
                }

                @Override
                public Bundle getBundle(String location) {
                    return null;
                }

                @Override
                public Bundle getBundle(long id) {
                    return null;
                }

                @Override
                public Bundle getBundle() {
                    return null;
                }

                @Override
                public ServiceReference<?>[] getAllServiceReferences(String clazz, String filter) throws InvalidSyntaxException {
                    return null;
                }

                @Override
                public Filter createFilter(String filter) throws InvalidSyntaxException {
                    return null;
                }

                @Override
                public void addServiceListener(ServiceListener listener, String filter) throws InvalidSyntaxException {
                }

                @Override
                public void addServiceListener(ServiceListener listener) {
                }

                @Override
                public void addFrameworkListener(FrameworkListener listener) {
                }

                @Override
                public void addBundleListener(BundleListener listener) {
                }

                @Override
                public <S> ServiceRegistration<S> registerService(Class<S> clazz, ServiceFactory<S> factory, Dictionary<String, ?> properties) {
                    return null;
                }

                @Override
                public <S> ServiceObjects<S> getServiceObjects(ServiceReference<S> reference) {
                    return null;
                }
            };
        }

        @Override
        public Map<X509Certificate, List<X509Certificate>> getSignerCertificates(int signersType) {
            return null;
        }

        @Override
        public Version getVersion() {
            return null;
        }

        @Override
        public <A> A adapt(Class<A> type) {
            return null;
        }

        @Override
        public File getDataFile(String filename) {
            return null;
        }
    };
    {
        Servlet servlet = new DefaultServlet();
        ContextModel contextModel = new ContextModel(httpContext, testBundle, getClass().getClassLoader());
        ServletModel servletModel = new ServletModel(contextModel, servlet, "/", null, null, null);
        server.addServlet(servletModel);
        server.removeServlet(servletModel);
    }
    final Set<Object> oldbeans = new HashSet<>(container.getBeans());
    Servlet servlet = new DefaultServlet();
    ContextModel contextModel = new ContextModel(httpContext, testBundle, getClass().getClassLoader());
    ServletModel servletModel = new ServletModel(contextModel, servlet, "/", null, null, null);
    server.addServlet(servletModel);
    // assertNotSame("OldSize:"+oldbeans.size()+" new size: "+container.getBeans().size(),
    // oldbeans.size(), container.getBeans().size());
    server.removeServlet(servletModel);
    // System.out.println(listener.diff(oldbeans));
    assertEquals(oldbeans.size(), container.getBeans().size());
}

static void configureContext(ServletContextHandler root, JettyConfiguration config) {
    // Context path
    String contextPath = config.contextPath().get();
    if (contextPath != null && contextPath.length() > 0) {
        root.setContextPath(contextPath);
    }
    // Root resource base
    String resourcePath = config.resourcePath().get();
    if (resourcePath != null && resourcePath.length() > 0) {
        root.addServlet(DefaultServlet.class, "/");
        root.setResourceBase(resourcePath);
    }
    // Max form content size
    Integer maxFormContentSize = config.maxFormContentSize().get();
    if (maxFormContentSize != null) {
        root.setMaxFormContentSize(maxFormContentSize);
    }
    // Virtual hosts
    String virtualHostsConfigString = config.virtualHosts().get();
    if (virtualHostsConfigString != null) {
        String[] virtualHosts = virtualHostsConfigString.split(COMA);
        if (virtualHosts.length > 0) {
            root.setVirtualHosts(virtualHosts);
        }
    }
    // Welcome files
    String welcomeFilesConfigString = config.welcomeFiles().get();
    if (welcomeFilesConfigString == null) {
        root.setWelcomeFiles(DEFAULT_WELCOME_FILES);
    } else {
        String[] welcomeFiles = welcomeFilesConfigString.split(COMA);
        if (welcomeFiles.length == 0) {
            root.setWelcomeFiles(DEFAULT_WELCOME_FILES);
        } else {
            root.setWelcomeFiles(welcomeFiles);
        }
    }
}

@BeforeClass
public void beforeClass() throws Exception {
    if ((!this.startServerOnce) || (reusableServer == null)) {
        server = new Server(port);
        // Add a context for authorization service
        ServletContextHandler context = new ServletContextHandler(servletContextHandlerOption);
        if (this.annotationBasedConfig) {
            context.getInitParams().put("contextClass", "org.springframework.web.context.support.AnnotationConfigWebApplicationContext");
        }
        context.getInitParams().put("contextConfigLocation", contextLocations);
        context.getInitParams().put("spring.profiles.active", activeProfiles);
        ServletHolder defaultServletHolder = new ServletHolder(DefaultServlet.class);
        defaultServletHolder.setName("default");
        // Add default servlet in order to make <mvc:default-servlet-handler /> work in unit tests.
        // "/" servlet mapping will be overriden by dispatcher, but default servlet will stay in the context
        context.addServlet(defaultServletHolder, "/");
        ServletHolder dispatcherServletHolder = new ServletHolder(DispatcherServlet.class);
        dispatcherServletHolder.setName("dispatcher");
        dispatcherServletHolder.setInitOrder(1);
        // Reuse beans detected by ContextLoaderListener so we configure an
        // empty contextConfigLocation
        dispatcherServletHolder.setInitParameter("contextConfigLocation", "");
        context.addServlet(dispatcherServletHolder, "/");
        context.addEventListener(new ContextLoaderListener());
        if (useOpenEntityManagerInViewFilter) {
            context.addFilter(OpenEntityManagerInViewFilter.class, "/*", EnumSet.of(DispatcherType.REQUEST));
        }
        // Customize context then start the server.
        server.setHandler(customizeContextHandler(context));
        server.start();
        if (this.startServerOnce) {
            reusableServer = server;
        }
    }
}

@Override
public void onStartup(ServletContext servletContext) throws ServletException {
    Preconditions.checkNotNull(rhizomeContext, "Rhizome context cannot be null for startup.");
    servletContext.addListener(new SessionListener());
    /*
         * We have the luxury of being able to access the RhizomeConfiguration from the rhizomeContext. This allows us
         * to conditionally enabled session clustering among other things.
         */
    RhizomeConfiguration configuration = rhizomeContext.getBean(RhizomeConfiguration.class);
    JettyConfiguration jettyConfiguration = rhizomeContext.getBean(JettyConfiguration.class);
    if (configuration.isSessionClusteringEnabled()) {
        FilterRegistration.Dynamic addFilter = servletContext.addFilter(HAZELCAST_SESSION_FILTER_NAME, rhizomeContext.getBean(WebFilter.class));
        addFilter.addMappingForUrlPatterns(Sets.newEnumSet(ImmutableSet.of(DispatcherType.FORWARD, DispatcherType.REQUEST, DispatcherType.REQUEST), DispatcherType.class), false, "/*");
        addFilter.setAsyncSupported(true);
    }
    // Prevent jersey-spring3 from trying to initialize a spring application context.
    // servletContext.setInitParameter( CONTEXT_CONFIG_LOCATION_PARAMETER_NAME , "" );
    servletContext.addListener(new ContextLoaderListener(rhizomeContext));
    servletContext.addListener(new RequestContextListener());
    // Register the health check registry.
    servletContext.setAttribute(HealthCheckServlet.HEALTH_CHECK_REGISTRY, rhizomeContext.getBean("getHealthCheckRegistry", HealthCheckRegistry.class));
    servletContext.setAttribute(MetricsServlet.METRICS_REGISTRY, rhizomeContext.getBean("getMetricRegistry", MetricRegistry.class));
    /*
         *
         */
    ServletRegistration.Dynamic adminServlet = servletContext.addServlet("admin", AdminServlet.class);
    adminServlet.setLoadOnStartup(1);
    adminServlet.addMapping("/admin/*");
    adminServlet.setInitParameter("show-jvm-metrics", "true");
    /*
         * Jersey Servlet For lovers of the JAX-RS standard.
         */
    ServletRegistration.Dynamic jerseyDispatcher = servletContext.addServlet("defaultJerseyServlet", new ServletContainer());
    jerseyDispatcher.setInitParameter("javax.ws.rs.Application", RhizomeApplication.class.getName());
    jerseyDispatcher.setLoadOnStartup(1);
    jerseyDispatcher.addMapping("/health/*");
    /*
         * Default Servlet
         */
    if (jettyConfiguration.isDefaultServletEnabled()) {
        ServletRegistration.Dynamic defaultServlet = servletContext.addServlet("default", new DefaultServlet());
        defaultServlet.addMapping(new String[] { "/*" });
        defaultServlet.setLoadOnStartup(1);
        defaultServlet.setAsyncSupported(true);
    }
    registerDispatcherServlets(servletContext);
}

/**
     * Static handler : server static pages
     *
     * @return the generated Handler
     */
@Override
protected Handler buildApplicationHandler() {
    // Servlet for static resources
    final ServletHolder staticServlet = new ServletHolder("static-content", DefaultServlet.class);
    staticServlet.setInitParameter("resourceBase", getConfiguration().getDirectoryPath());
    staticServlet.setInitParameter("dirAllowed", "true");
    staticServlet.setInitParameter("pathInfoOnly", "true");
    // Jersey resources servlet : add admin resources
    final ResourceConfig resourceConfig = new ResourceConfig();
    resourceConfig.register(JacksonJsonProvider.class).register(JacksonFeature.class).register(// Register a Generic Exception Mapper
    new GenericExceptionMapper()).register(new AdminStatusResource());
    // Use chunk size also in response
    resourceConfig.property(ServerProperties.OUTBOUND_CONTENT_LENGTH_BUFFER, VitamConfiguration.getChunkSize());
    // Cleaner filter
    resourceConfig.register(ConsumeAllAfterResponseFilter.class);
    final ServletContainer servletContainer = new ServletContainer(resourceConfig);
    final ServletHolder sh = new ServletHolder(servletContainer);
    // Context handler for /
    final ServletContextHandler context = new ServletContextHandler(ServletContextHandler.NO_SESSIONS);
    context.setResourceBase(getConfiguration().getDirectoryPath());
    context.setContextPath("/");
    // Mixing everything
    // TODO P1: externalise constant in config
    context.addServlet(staticServlet, "/doc/*");
    context.addServlet(sh, "/*");
    return context;
}

protected Server createStaticResourcesServer(Server server, ServletContextHandler context, String home) throws Exception {
    context.setContextPath("/");
    SessionHandler sh = new SessionHandler();
    context.setSessionHandler(sh);
    if (home != null) {
        String[] resources = home.split(":");
        if (LOG.isDebugEnabled()) {
            LOG.debug(">>> Protocol found: " + resources[0] + ", and resource: " + resources[1]);
        }
        if (resources[0].equals("classpath")) {
            context.setBaseResource(new JettyClassPathResource(getCamelContext().getClassResolver(), resources[1]));
        } else if (resources[0].equals("file")) {
            context.setBaseResource(Resource.newResource(resources[1]));
        }
        DefaultServlet defaultServlet = new DefaultServlet();
        ServletHolder holder = new ServletHolder(defaultServlet);
        // avoid file locking on windows
        // http://stackoverflow.com/questions/184312/how-to-make-jetty-dynamically-load-static-pages
        holder.setInitParameter("useFileMappedBuffer", "false");
        context.addServlet(holder, "/");
    }
    server.setHandler(context);
    return server;
}

/**
     * Function used to configure Jetty and return a Server instance.
     * @param port the port to run Jetty on.
     * @return the {@link Server} instance.
     */
protected Server configureJetty(final int port) {
    final Server server = new Server();
    final ServerConnector connector = new ServerConnector(server);
    // TODO: make all of this configurable
    connector.setIdleTimeout((int) TimeUnit.HOURS.toMillis(1));
    connector.setSoLingerTime(-1);
    connector.setPort(port);
    server.addConnector(connector);
    // set the injector as an attribute in the context
    sch.setAttribute("guice-injector", injector);
    // prevent the JSESSIONID from getting set via a URL argument
    sch.setInitParameter("org.eclipse.jetty.servlet.SessionIdPathParameterName", "none");
    // add the font mime type by default
    sch.getMimeTypes().addMimeMapping("woff", "application/x-font-woff");
    // if we're using a database, then install the filter
    if (!settings.getDatabaseSettings().getNotUsed()) {
        // setup a FilterHolder for the Guice Persistence
        final FilterHolder persistFilter = new FilterHolder(injector.getInstance(PersistFilter.class));
        // add the filter to the context
        sch.addFilter(persistFilter, "/*", DISPATCHER_TYPES);
    }
    // setup a FilterHolder for WebSockets
    final FilterHolder webSocketFilter = new FilterHolder(Jetty9WebSocketFilter.class);
    // set the app factor as the Guice Web App Factory
    webSocketFilter.setInitParameter("applicationFactoryClassName", GuiceWebApplicationFactory.class.getName());
    // tell the filter to use the injector in the context instead of making a new one
    webSocketFilter.setInitParameter("injectorContextAttribute", "guice-injector");
    // setup the filter mapping
    webSocketFilter.setInitParameter(WicketFilter.FILTER_MAPPING_PARAM, "/*");
    webSocketFilter.setInitParameter("configuration", "deployment");
    // add the filter to the context
    sch.addFilter(webSocketFilter, "/*", DISPATCHER_TYPES);
    // add the default servlet as Guice & Wicket will take care of everything for us
    sch.addServlet(DefaultServlet.class, "/*");
    server.setHandler(sch);
    return server;
}

@Override
public void init(ServletContextHandler context) {
    ServletHolder servlet = new ServletHolder(new DefaultServlet());
    servlet.setInitParameter("dirAllowed", "true");
    servlet.setInitParameter("resourceBase", runtimeInfo.getStaticWebDir());
    servlet.setInitParameter("cacheControl", "max-age=0,public");
    context.addServlet(servlet, "/*");
}

@Override
protected void doConfigure() throws Exception {
    // current value or system property or conf/application.conf or default value
    jettyConfiguration(overlayedNinjaProperties.get(KEY_NINJA_JETTY_CONFIGURATION, this.jettyConfiguration, DEFAULT_JETTY_CONFIGURATION));
    // build jetty server, context, and servlet
    if (this.jettyConfiguration != null) {
        String[] configs = this.jettyConfiguration.split(",");
        for (String config : configs) {
            jetty = buildServerOrApplyConfiguration(config, jetty);
        }
        // since we don't know host and port, try to get it from jetty
        tryToSetHostAndPortFromJetty();
    } else {
        // create very simple jetty configuration
        jetty = new Server();
        if (port > -1) {
            // build http cleartext connector
            ServerConnector http = new ServerConnector(jetty);
            http.setPort(port);
            http.setIdleTimeout(idleTimeout);
            if (host != null) {
                http.setHost(host);
            }
            jetty.addConnector(http);
        }
        if (sslPort > -1) {
            // build https secure connector
            // http://git.eclipse.org/c/jetty/org.eclipse.jetty.project.git/tree/examples/embedded/src/main/java/org/eclipse/jetty/embedded/ManyConnectors.java
            HttpConfiguration httpConfig = new HttpConfiguration();
            httpConfig.setSecureScheme("https");
            httpConfig.setSecurePort(sslPort);
            httpConfig.setOutputBufferSize(32768);
            HttpConfiguration httpsConfig = new HttpConfiguration(httpConfig);
            httpsConfig.addCustomizer(new SecureRequestCustomizer());
            // unfortunately jetty seems to only work when we pass a keystore
            // and truststore (as opposed to our own prepared SSLContext)
            // call createSSLContext() to simply verify configuration is correct
            this.createSSLContext();
            SslContextFactory sslContextFactory = new SslContextFactory();
            sslContextFactory.setKeyStore(StandaloneHelper.loadKeyStore(this.sslKeystoreUri, this.sslKeystorePassword.toCharArray()));
            sslContextFactory.setKeyManagerPassword(this.sslKeystorePassword);
            sslContextFactory.setTrustStore(StandaloneHelper.loadKeyStore(this.sslTruststoreUri, this.sslTruststorePassword.toCharArray()));
            ServerConnector https = new ServerConnector(jetty, new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()), new HttpConnectionFactory(httpsConfig));
            https.setPort(sslPort);
            https.setIdleTimeout(idleTimeout);
            jetty.addConnector(https);
        }
    }
    this.ninjaServletListener.setNinjaProperties(ninjaProperties);
    this.contextHandler = new ServletContextHandler(jetty, getContextPath());
    this.contextHandler.addEventListener(ninjaServletListener);
    this.contextHandler.addFilter(GuiceFilter.class, "/*", null);
    this.contextHandler.addServlet(DefaultServlet.class, "/");
    // disable directory browsing
    this.contextHandler.setInitParameter("org.eclipse.jetty.servlet.Default.dirAllowed", "false");
    // Add an error handler that does not print stack traces in case
    // something happens that is not under control of Ninja
    this.contextHandler.setErrorHandler(new SilentErrorHandler());
}

@Override
protected void doConfigure() throws Exception {
    // current value or system property or conf/application.conf or default value
    jettyConfiguration(overlayedNinjaProperties.get(KEY_NINJA_JETTY_CONFIGURATION, this.jettyConfiguration, DEFAULT_JETTY_CONFIGURATION));
    // build jetty server, context, and servlet
    if (this.jettyConfiguration != null) {
        String[] configs = this.jettyConfiguration.split(",");
        for (String config : configs) {
            jetty = buildServerOrApplyConfiguration(config, jetty);
        }
        // since we don't know host and port, try to get it from jetty
        tryToSetHostAndPortFromJetty();
    } else {
        // create very simple jetty configuration
        jetty = new Server();
        if (port > -1) {
            // build http cleartext connector
            ServerConnector http = new ServerConnector(jetty);
            http.setPort(port);
            http.setIdleTimeout(idleTimeout);
            if (host != null) {
                http.setHost(host);
            }
            jetty.addConnector(http);
        }
        if (sslPort > -1) {
            // build https secure connector
            // http://git.eclipse.org/c/jetty/org.eclipse.jetty.project.git/tree/examples/embedded/src/main/java/org/eclipse/jetty/embedded/ManyConnectors.java
            HttpConfiguration httpConfig = new HttpConfiguration();
            httpConfig.setSecureScheme("https");
            httpConfig.setSecurePort(sslPort);
            httpConfig.setOutputBufferSize(32768);
            HttpConfiguration httpsConfig = new HttpConfiguration(httpConfig);
            httpsConfig.addCustomizer(new SecureRequestCustomizer());
            // unfortunately jetty seems to only work when we pass a keystore
            // and truststore (as opposed to our own prepared SSLContext)
            // call createSSLContext() to simply verify configuration is correct
            this.createSSLContext();
            SslContextFactory sslContextFactory = new SslContextFactory();
            sslContextFactory.setKeyStore(StandaloneHelper.loadKeyStore(this.sslKeystoreUri, this.sslKeystorePassword.toCharArray()));
            sslContextFactory.setKeyManagerPassword(this.sslKeystorePassword);
            sslContextFactory.setTrustStore(StandaloneHelper.loadKeyStore(this.sslTruststoreUri, this.sslTruststorePassword.toCharArray()));
            ServerConnector https = new ServerConnector(jetty, new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()), new HttpConnectionFactory(httpsConfig));
            https.setPort(sslPort);
            https.setIdleTimeout(idleTimeout);
            jetty.addConnector(https);
        }
    }
    this.ninjaServletListener.setNinjaProperties(ninjaProperties);
    this.contextHandler = new ServletContextHandler(jetty, getContextPath());
    this.contextHandler.addEventListener(ninjaServletListener);
    this.contextHandler.addFilter(GuiceFilter.class, "/*", null);
    this.contextHandler.addServlet(DefaultServlet.class, "/");
    // disable directory browsing
    this.contextHandler.setInitParameter("org.eclipse.jetty.servlet.Default.dirAllowed", "false");
    // Add an error handler that does not print stack traces in case
    // something happens that is not under control of Ninja
    this.contextHandler.setErrorHandler(new SilentErrorHandler());
}

public void initJetty() {
    List<org.eclipse.jetty.server.Handler> handlerList = new ArrayList<org.eclipse.jetty.server.Handler>();
    // the raw file resource handler
    {
        ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
        context.setContextPath("/images");
        context.setBaseResource(Resource.newClassPathResource("/images/"));
        context.addServlet(new ServletHolder(new DefaultServlet()), "/*");
        handlerList.add(context);
    }
    // the service descriptor handler
    {
        ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
        context.setContextPath("/scpd");
        context.setBaseResource(Resource.newClassPathResource("/scpd/"));
        context.addServlet(new ServletHolder(new DefaultServlet()), "/*");
        handlerList.add(context);
    }
    // the description handler
    {
        ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
        context.setContextPath("/description");
        context.addServlet(new ServletHolder(new DescriptionServlet(mediaServer)), "/*");
        handlerList.add(context);
    }
    // the content access handler
    {
        ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
        context.setContextPath("/fetch");
        context.addServlet(new ServletHolder(new FetchServlet()), "/*");
        handlerList.add(context);
    }
    // the content directory handler
    {
        ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
        context.setContextPath("/service");
        UpnpServiceServlet servlet = new UpnpServiceServlet();
        servlet.getServices().add(cd);
        servlet.getServices().add(cm);
        context.addServlet(new ServletHolder(servlet), "/*");
        handlerList.add(context);
    }
    // the service descriptor handler
    {
        ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
        context.setContextPath("/");
        context.addServlet(new ServletHolder(new LoggingServlet()), "/*");
        handlerList.add(context);
    }
    ContextHandlerCollection contexts = new ContextHandlerCollection();
    contexts.setHandlers(handlerList.toArray(new org.eclipse.jetty.server.Handler[] {}));
    jettyServer.setHandler(contexts);
}

/**
   * Start the web server including setup.
   * @throws Exception
   */
public void start() throws Exception {
    if (embeddedJetty == null) {
        return;
    }
    final boolean authEnabled = config.getBoolean(ExecConstants.USER_AUTHENTICATION_ENABLED);
    if (authEnabled && !context.getAuthProvider().containsFactory(PlainFactory.SIMPLE_NAME)) {
        logger.warn("Not starting web server. Currently Drill supports web authentication only through " + "username/password. But PLAIN mechanism is not configured.");
        return;
    }
    final ServerConnector serverConnector;
    if (config.getBoolean(ExecConstants.HTTP_ENABLE_SSL)) {
        serverConnector = createHttpsConnector();
    } else {
        serverConnector = createHttpConnector();
    }
    embeddedJetty.addConnector(serverConnector);
    // Add resources
    final ErrorHandler errorHandler = new ErrorHandler();
    errorHandler.setShowStacks(true);
    errorHandler.setShowMessageInTitle(true);
    final ServletContextHandler servletContextHandler = new ServletContextHandler(ServletContextHandler.SESSIONS);
    servletContextHandler.setErrorHandler(errorHandler);
    servletContextHandler.setContextPath("/");
    final ServletHolder servletHolder = new ServletHolder(new ServletContainer(new DrillRestServer(workManager)));
    servletHolder.setInitOrder(1);
    servletContextHandler.addServlet(servletHolder, "/*");
    servletContextHandler.addServlet(new ServletHolder(new MetricsServlet(metrics)), "/status/metrics");
    servletContextHandler.addServlet(new ServletHolder(new ThreadDumpServlet()), "/status/threads");
    final ServletHolder staticHolder = new ServletHolder("static", DefaultServlet.class);
    // Get resource URL for Drill static assets, based on where Drill icon is located
    String drillIconResourcePath = Resource.newClassPathResource(BASE_STATIC_PATH + DRILL_ICON_RESOURCE_RELATIVE_PATH).getURL().toString();
    staticHolder.setInitParameter("resourceBase", drillIconResourcePath.substring(0, drillIconResourcePath.length() - DRILL_ICON_RESOURCE_RELATIVE_PATH.length()));
    staticHolder.setInitParameter("dirAllowed", "false");
    staticHolder.setInitParameter("pathInfoOnly", "true");
    servletContextHandler.addServlet(staticHolder, "/static/*");
    if (authEnabled) {
        servletContextHandler.setSecurityHandler(createSecurityHandler());
        servletContextHandler.setSessionHandler(createSessionHandler(servletContextHandler.getSecurityHandler()));
    }
    if (config.getBoolean(ExecConstants.HTTP_CORS_ENABLED)) {
        FilterHolder holder = new FilterHolder(CrossOriginFilter.class);
        holder.setInitParameter(CrossOriginFilter.ALLOWED_ORIGINS_PARAM, StringUtils.join(config.getStringList(ExecConstants.HTTP_CORS_ALLOWED_ORIGINS), ","));
        holder.setInitParameter(CrossOriginFilter.ALLOWED_METHODS_PARAM, StringUtils.join(config.getStringList(ExecConstants.HTTP_CORS_ALLOWED_METHODS), ","));
        holder.setInitParameter(CrossOriginFilter.ALLOWED_HEADERS_PARAM, StringUtils.join(config.getStringList(ExecConstants.HTTP_CORS_ALLOWED_HEADERS), ","));
        holder.setInitParameter(CrossOriginFilter.ALLOW_CREDENTIALS_PARAM, String.valueOf(config.getBoolean(ExecConstants.HTTP_CORS_CREDENTIALS)));
        for (String path : new String[] { "*.json", "/storage/*/enable/*", "/status*" }) {
            servletContextHandler.addFilter(holder, path, EnumSet.of(DispatcherType.REQUEST));
        }
    }
    embeddedJetty.setHandler(servletContextHandler);
    embeddedJetty.start();
}

private ContextHandler makeContext(final String contextPath, final JettyEnv env, final Config cfg) {
    final ServletContextHandler app = new ServletContextHandler();
    // This enables the use of sessions in Jetty, feature available
    // for Gerrit plug-ins to enable user-level sessions.
    //
    app.setSessionHandler(new SessionHandler());
    app.setErrorHandler(new HiddenErrorHandler());
    // This is the path we are accessed by clients within our domain.
    //
    app.setContextPath(contextPath);
    // HTTP front-end filters to be used as surrogate of Apache HTTP
    // reverse-proxy filtering.
    // It is meant to be used as simpler tiny deployment of custom-made
    // security enforcement (Security tokens, IP-based security filtering, others)
    String[] filterClassNames = cfg.getStringList("httpd", null, "filterClass");
    for (String filterClassName : filterClassNames) {
        try {
            @SuppressWarnings("unchecked") Class<? extends Filter> filterClass = (Class<? extends Filter>) Class.forName(filterClassName);
            Filter filter = env.webInjector.getInstance(filterClass);
            app.addFilter(new FilterHolder(filter), "/*", EnumSet.of(DispatcherType.REQUEST, DispatcherType.ASYNC));
        } catch (Throwable e) {
            String errorMessage = "Unable to instantiate front-end HTTP Filter " + filterClassName;
            log.error(errorMessage, e);
            throw new IllegalArgumentException(errorMessage, e);
        }
    }
    // Perform the same binding as our web.xml would do, but instead
    // of using the listener to create the injector pass the one we
    // already have built.
    //
    GuiceFilter filter = env.webInjector.getInstance(GuiceFilter.class);
    app.addFilter(new FilterHolder(filter), "/*", EnumSet.of(DispatcherType.REQUEST, DispatcherType.ASYNC));
    app.addEventListener(new GuiceServletContextListener() {

        @Override
        protected Injector getInjector() {
            return env.webInjector;
        }
    });
    // Jetty requires at least one servlet be bound before it will
    // bother running the filter above. Since the filter has all
    // of our URLs except the static resources, the only servlet
    // we need to bind is the default static resource servlet from
    // the Jetty container.
    //
    final ServletHolder ds = app.addServlet(DefaultServlet.class, "/");
    ds.setInitParameter("dirAllowed", "false");
    ds.setInitParameter("redirectWelcome", "false");
    ds.setInitParameter("useFileMappedBuffer", "false");
    ds.setInitParameter("gzip", "true");
    app.setWelcomeFiles(new String[0]);
    return app;
}

private void configureContextWithServletsAndResources(final ServletContextHandler contextHandler) throws MalformedURLException, IOException {
    // configure context base directory (required for RAP/RWT resources)
    final IPath contextBase = Platform.getStateLocation(getBundle()).append("context");
    contextHandler.setBaseResource(Resource.newResource(contextBase.toFile()));
    // configure defaults for resources served by Jetty's DefaultServlet
    if (Platform.inDevelopmentMode()) {
        contextHandler.setInitParameter("org.eclipse.jetty.servlet.Default.dirAllowed", "true");
        contextHandler.setInitParameter("org.eclipse.jetty.servlet.Default.useFileMappedBuffer", "false");
        contextHandler.setInitParameter("org.eclipse.jetty.servlet.Default.maxCachedFiles", "0");
    } else {
        contextHandler.setInitParameter("org.eclipse.jetty.servlet.Default.dirAllowed", "false");
        contextHandler.setInitParameter("org.eclipse.jetty.servlet.Default.maxCacheSize", "2000000");
        contextHandler.setInitParameter("org.eclipse.jetty.servlet.Default.maxCachedFileSize", "254000");
        contextHandler.setInitParameter("org.eclipse.jetty.servlet.Default.maxCachedFiles", "1000");
        contextHandler.setInitParameter("org.eclipse.jetty.servlet.Default.useFileMappedBuffer", "true");
    }
    // initialize and start RWT application
    adminApplicationRunner = new ApplicationRunner(new AdminApplicationConfiguration(), contextHandler.getServletContext());
    adminApplicationRunner.start();
    // serve admin application directly
    contextHandler.addServlet(new AdminServletHolder(new RWTServlet()), "/admin");
    // register additional static resources references in body html
    final ServletHolder staticResources = new AdminServletHolder(new DefaultServlet());
    staticResources.setInitParameter("resourceBase", FileLocator.resolve(FileLocator.find(getBundle(), new Path("html"), null)).toExternalForm());
    contextHandler.addServlet(staticResources, "/static/*");
    // redirect to admin
    contextHandler.addServlet(new AdminServletHolder(new HttpServlet() {

        private static final long serialVersionUID = 1L;

        @Override
        protected void doGet(final HttpServletRequest req, final HttpServletResponse resp) throws ServletException, IOException {
            resp.sendRedirect("/admin");
        }
    }), "");
    // serve context resources (required for RAP/RWT resources)
    contextHandler.addServlet(new AdminServletHolder(new DefaultServlet()), "/*");
    // register Logback status servlet
    try {
        // note, we don't reference the class directly because the package import is optional
        final Class<?> servletClass = AdminUiActivator.getInstance().getBundle().loadClass("ch.qos.logback.classic.ViewStatusMessagesServlet");
        contextHandler.addServlet(new AdminServletHolder((Servlet) servletClass.newInstance()), "/logbackstatus");
    } catch (final ClassNotFoundExceptionLinkageError |  e) {
        LOG.warn("Logback status servlet not available. {}", e.getMessage(), e);
    } catch (final Exception e) {
        LOG.error("An error occurred while registering the Logback status servlet. {}", e.getMessage(), e);
    }
    // allow extension using custom servlets
    final AdminServletTracker adminServletTracker = new AdminServletTracker(getBundle().getBundleContext(), contextHandler);
    contextHandler.addBean(new AbstractLifeCycle() {

        @Override
        protected void doStart() throws Exception {
            adminServletTracker.open();
        }

        @Override
        protected void doStop() throws Exception {
            adminServletTracker.close();
        }
    });
}

private void initializeWebServer(final Builder b, int queueSize) {
    // Set handling for low resource conditions.
    final LowResourceMonitor low = new LowResourceMonitor(webServer);
    low.setLowResourcesIdleTimeout(10000);
    webServer.addBean(low);
    Connector connector = createChannelConnector(queueSize, b);
    webServer.addConnector(connector);
    RewriteHandler rwHandler = new RewriteHandler();
    rwHandler.setRewriteRequestURI(true);
    rwHandler.setRewritePathInfo(false);
    RewriteRegexRule rootRule = new RewriteRegexRule();
    rootRule.setRegex("^/$");
    rootRule.setReplacement(b.contextRootRewriteTarget);
    rootRule.setTerminating(true);
    rwHandler.addRule(rootRule);
    rwHandler.setHandler(webAppContext);
    // Configure web application contexts for the web server
    ContextHandlerCollection contexts = new ContextHandlerCollection();
    contexts.addHandler(rwHandler);
    webServer.setHandler(contexts);
    addServlet("jmx", "/jmx", JMXJsonServlet.class);
    addServlet("conf", "/conf", ConfServlet.class);
    addServlet("stacks", "/stacks", StackServlet.class);
    for (Pair<String, Class<? extends HttpServlet>> p : b.servlets) {
        addServlet(p.getFirst(), "/" + p.getFirst(), p.getSecond());
    }
    ServletContextHandler staticCtx = new ServletContextHandler(contexts, "/static");
    staticCtx.setResourceBase(appDir + "/static");
    staticCtx.addServlet(DefaultServlet.class, "/*");
    staticCtx.setDisplayName("static");
    String logDir = getLogDir(b.conf);
    if (logDir != null) {
        ServletContextHandler logCtx = new ServletContextHandler(contexts, "/logs");
        setContextAttributes(logCtx.getServletContext(), b.contextAttrs);
        logCtx.addServlet(AdminAuthorizedServlet.class, "/*");
        logCtx.setResourceBase(logDir);
        logCtx.setDisplayName("logs");
    }
}

@Override
public void serveFiles(final String pathSpec, final FileContext fileContext) {
    if (webappContext == null) {
        try {
            initServer();
        } catch (Exception e) {
            throw new IllegalStateException(e);
        }
    }
    final ServletHolder servletHolder = new ServletHolder(new DefaultServlet());
    servletHolder.setInitParameter("resourceBase", fileContext.getBaseDir().getAbsolutePath());
    servletHolder.setInitParameter("dirAllowed", String.valueOf(fileContext.isCollectionAllow()));
    servletHolder.setInitParameter("acceptRanges", Boolean.TRUE.toString());
    servletHolder.setInitParameter("pathInfoOnly", Boolean.TRUE.toString());
    webappContext.getServletHandler().addServletWithMapping(servletHolder, pathSpec);
}

private ContextHandler makeContext(final String contextPath, final JettyEnv env) throws MalformedURLException, IOException {
    final ServletContextHandler app = new ServletContextHandler();
    // This is the path we are accessed by clients within our domain.
    //
    app.setContextPath(contextPath);
    // Serve static resources directly from our JAR. This way we don't
    // need to unpack them into yet another temporary directory prior to
    // serving to clients.
    //
    app.setBaseResource(getBaseResource());
    // Perform the same binding as our web.xml would do, but instead
    // of using the listener to create the injector pass the one we
    // already have built.
    //
    app.addFilter(GuiceFilter.class, "/*", FilterMapping.DEFAULT);
    app.addEventListener(new GuiceServletContextListener() {

        @Override
        protected Injector getInjector() {
            return env.webInjector;
        }
    });
    // Jetty requires at least one servlet be bound before it will
    // bother running the filter above. Since the filter has all
    // of our URLs except the static resources, the only servlet
    // we need to bind is the default static resource servlet from
    // the Jetty container.
    //
    final ServletHolder ds = app.addServlet(DefaultServlet.class, "/");
    ds.setInitParameter("dirAllowed", "false");
    ds.setInitParameter("redirectWelcome", "false");
    ds.setInitParameter("useFileMappedBuffer", "false");
    ds.setInitParameter("gzip", "true");
    app.setWelcomeFiles(new String[0]);
    return app;
}

private static WebAppContext setupWebAppContext(ContextHandlerCollection contexts, ZeppelinConfiguration conf) {
    WebAppContext webApp = new WebAppContext();
    webApp.setContextPath(conf.getServerContextPath());
    File warPath = new File(conf.getString(ConfVars.ZEPPELIN_WAR));
    if (warPath.isDirectory()) {
        // Development mode, read from FS
        // webApp.setDescriptor(warPath+"/WEB-INF/web.xml");
        webApp.setResourceBase(warPath.getPath());
        webApp.setParentLoaderPriority(true);
    } else {
        // use packaged WAR
        webApp.setWar(warPath.getAbsolutePath());
        File warTempDirectory = new File(conf.getRelativeDir(ConfVars.ZEPPELIN_WAR_TEMPDIR));
        warTempDirectory.mkdir();
        LOG.info("ZeppelinServer Webapp path: {}", warTempDirectory.getPath());
        webApp.setTempDirectory(warTempDirectory);
    }
    // Explicit bind to root
    webApp.addServlet(new ServletHolder(new DefaultServlet()), "/*");
    contexts.addHandler(webApp);
    webApp.addFilter(new FilterHolder(CorsFilter.class), "/*", EnumSet.allOf(DispatcherType.class));
    webApp.setInitParameter("org.eclipse.jetty.servlet.Default.dirAllowed", Boolean.toString(conf.getBoolean(ConfVars.ZEPPELIN_SERVER_DEFAULT_DIR_ALLOWED)));
    return webApp;
}

private ContextHandler makeContext(final String contextPath, final JettyEnv env) throws MalformedURLException, IOException {
    final ServletContextHandler app = new ServletContextHandler();
    // This is the path we are accessed by clients within our domain.
    //
    app.setContextPath(contextPath);
    // Serve static resources directly from our JAR. This way we don't
    // need to unpack them into yet another temporary directory prior to
    // serving to clients.
    //
    app.setBaseResource(getBaseResource());
    // Perform the same binding as our web.xml would do, but instead
    // of using the listener to create the injector pass the one we
    // already have built.
    //
    app.addFilter(GuiceFilter.class, "/*", FilterMapping.DEFAULT);
    app.addEventListener(new GuiceServletContextListener() {

        @Override
        protected Injector getInjector() {
            return env.webInjector;
        }
    });
    // Jetty requires at least one servlet be bound before it will
    // bother running the filter above. Since the filter has all
    // of our URLs except the static resources, the only servlet
    // we need to bind is the default static resource servlet from
    // the Jetty container.
    //
    final ServletHolder ds = app.addServlet(DefaultServlet.class, "/");
    ds.setInitParameter("dirAllowed", "false");
    ds.setInitParameter("redirectWelcome", "false");
    ds.setInitParameter("useFileMappedBuffer", "false");
    ds.setInitParameter("gzip", "true");
    app.setWelcomeFiles(new String[0]);
    return app;
}

/**
   * Configure and create the server.
   */
public Server createServer() throws RestConfigException {
    // The configuration for the JAX-RS REST service
    ResourceConfig resourceConfig = new ResourceConfig();
    Map<String, String> metricTags = getMetricsTags();
    configureBaseApplication(resourceConfig, metricTags);
    setupResources(resourceConfig, getConfiguration());
    // Configure the servlet container
    ServletContainer servletContainer = new ServletContainer(resourceConfig);
    final FilterHolder servletHolder = new FilterHolder(servletContainer);
    server = new Server() {

        @Override
        protected void doStop() throws Exception {
            super.doStop();
            Application.this.metrics.close();
            Application.this.onShutdown();
            Application.this.shutdownLatch.countDown();
        }
    };
    MBeanContainer mbContainer = new MBeanContainer(ManagementFactory.getPlatformMBeanServer());
    server.addEventListener(mbContainer);
    server.addBean(mbContainer);
    MetricsListener metricsListener = new MetricsListener(metrics, "jetty", metricTags);
    List<URI> listeners = parseListeners(config.getList(RestConfig.LISTENERS_CONFIG), config.getInt(RestConfig.PORT_CONFIG), Arrays.asList("http", "https"), "http");
    for (URI listener : listeners) {
        log.info("Adding listener: " + listener.toString());
        NetworkTrafficServerConnector connector;
        if (listener.getScheme().equals("http")) {
            connector = new NetworkTrafficServerConnector(server);
        } else {
            SslContextFactory sslContextFactory = new SslContextFactory();
            // TODO: investigate this further. Would be better to use SubjectAltNames.
            if (!config.getString(RestConfig.SSL_KEYSTORE_LOCATION_CONFIG).isEmpty()) {
                sslContextFactory.setKeyStorePath(config.getString(RestConfig.SSL_KEYSTORE_LOCATION_CONFIG));
                sslContextFactory.setKeyStorePassword(config.getString(RestConfig.SSL_KEYSTORE_PASSWORD_CONFIG));
                sslContextFactory.setKeyManagerPassword(config.getString(RestConfig.SSL_KEY_PASSWORD_CONFIG));
                sslContextFactory.setKeyStoreType(config.getString(RestConfig.SSL_KEYSTORE_TYPE_CONFIG));
                if (!config.getString(RestConfig.SSL_KEYMANAGER_ALGORITHM_CONFIG).isEmpty()) {
                    sslContextFactory.setSslKeyManagerFactoryAlgorithm(config.getString(RestConfig.SSL_KEYMANAGER_ALGORITHM_CONFIG));
                }
            }
            sslContextFactory.setNeedClientAuth(config.getBoolean(RestConfig.SSL_CLIENT_AUTH_CONFIG));
            List<String> enabledProtocols = config.getList(RestConfig.SSL_ENABLED_PROTOCOLS_CONFIG);
            if (!enabledProtocols.isEmpty()) {
                sslContextFactory.setIncludeProtocols(enabledProtocols.toArray(new String[0]));
            }
            List<String> cipherSuites = config.getList(RestConfig.SSL_CIPHER_SUITES_CONFIG);
            if (!cipherSuites.isEmpty()) {
                sslContextFactory.setIncludeCipherSuites(cipherSuites.toArray(new String[0]));
            }
            if (!config.getString(RestConfig.SSL_ENDPOINT_IDENTIFICATION_ALGORITHM_CONFIG).isEmpty()) {
                sslContextFactory.setEndpointIdentificationAlgorithm(config.getString(RestConfig.SSL_ENDPOINT_IDENTIFICATION_ALGORITHM_CONFIG));
            }
            if (!config.getString(RestConfig.SSL_TRUSTSTORE_LOCATION_CONFIG).isEmpty()) {
                sslContextFactory.setTrustStorePath(config.getString(RestConfig.SSL_TRUSTSTORE_LOCATION_CONFIG));
                sslContextFactory.setTrustStorePassword(config.getString(RestConfig.SSL_TRUSTSTORE_PASSWORD_CONFIG));
                sslContextFactory.setTrustStoreType(config.getString(RestConfig.SSL_TRUSTSTORE_TYPE_CONFIG));
                if (!config.getString(RestConfig.SSL_TRUSTMANAGER_ALGORITHM_CONFIG).isEmpty()) {
                    sslContextFactory.setTrustManagerFactoryAlgorithm(config.getString(RestConfig.SSL_TRUSTMANAGER_ALGORITHM_CONFIG));
                }
            }
            sslContextFactory.setProtocol(config.getString(RestConfig.SSL_PROTOCOL_CONFIG));
            if (!config.getString(RestConfig.SSL_PROVIDER_CONFIG).isEmpty()) {
                sslContextFactory.setProtocol(config.getString(RestConfig.SSL_PROVIDER_CONFIG));
            }
            connector = new NetworkTrafficServerConnector(server, sslContextFactory);
        }
        connector.addNetworkTrafficListener(metricsListener);
        connector.setPort(listener.getPort());
        connector.setHost(listener.getHost());
        server.addConnector(connector);
    }
    ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
    context.setContextPath("/");
    ServletHolder defaultHolder = new ServletHolder("default", DefaultServlet.class);
    defaultHolder.setInitParameter("dirAllowed", "false");
    ResourceCollection staticResources = getStaticResources();
    if (staticResources != null) {
        context.setBaseResource(staticResources);
    }
    if (config.getBoolean(RestConfig.ENABLE_GZIP_COMPRESSION_CONFIG)) {
        FilterHolder gzipFilter = new FilterHolder(AsyncGzipFilter.class);
        // do not check if .gz file already exists for the requested resource
        gzipFilter.setInitParameter("checkGzExists", "false");
        gzipFilter.setInitParameter("methods", "GET,POST");
        context.addFilter(gzipFilter, "/*", null);
    }
    String authMethod = config.getString(RestConfig.AUTHENTICATION_METHOD_CONFIG);
    if (enableBasicAuth(authMethod)) {
        String realm = getConfiguration().getString(RestConfig.AUTHENTICATION_REALM_CONFIG);
        List<String> roles = getConfiguration().getList(RestConfig.AUTHENTICATION_ROLES_CONFIG);
        final SecurityHandler securityHandler = createSecurityHandler(realm, roles);
        context.setSecurityHandler(securityHandler);
    }
    String allowedOrigins = getConfiguration().getString(RestConfig.ACCESS_CONTROL_ALLOW_ORIGIN_CONFIG);
    if (allowedOrigins != null && !allowedOrigins.trim().isEmpty()) {
        FilterHolder filterHolder = new FilterHolder(CrossOriginFilter.class);
        filterHolder.setName("cross-origin");
        filterHolder.setInitParameter(CrossOriginFilter.ALLOWED_ORIGINS_PARAM, allowedOrigins);
        String allowedMethods = getConfiguration().getString(RestConfig.ACCESS_CONTROL_ALLOW_METHODS);
        if (allowedMethods != null && !allowedOrigins.trim().isEmpty()) {
            filterHolder.setInitParameter(CrossOriginFilter.ALLOWED_METHODS_PARAM, allowedMethods);
        }
        context.addFilter(filterHolder, "/*", EnumSet.of(DispatcherType.REQUEST));
    }
    context.addFilter(servletHolder, "/*", null);
    configurePostResourceHandling(context);
    context.addServlet(defaultHolder, "/*");
    RequestLogHandler requestLogHandler = new RequestLogHandler();
    Slf4jRequestLog requestLog = new Slf4jRequestLog();
    requestLog.setLoggerName(config.getString(RestConfig.REQUEST_LOGGER_NAME_CONFIG));
    requestLog.setLogLatency(true);
    requestLogHandler.setRequestLog(requestLog);
    HandlerCollection handlers = new HandlerCollection();
    handlers.setHandlers(new Handler[] { context, new DefaultHandler(), requestLogHandler });
    /* Needed for graceful shutdown as per `setStopTimeout` documentation */
    StatisticsHandler statsHandler = new StatisticsHandler();
    statsHandler.setHandler(handlers);
    server.setHandler(statsHandler);
    int gracefulShutdownMs = getConfiguration().getInt(RestConfig.SHUTDOWN_GRACEFUL_MS_CONFIG);
    if (gracefulShutdownMs > 0) {
        server.setStopTimeout(gracefulShutdownMs);
    }
    server.setStopAtShutdown(true);
    return server;
}

/**
	 * Add Jetty's {@code DefaultServlet} to the given {@link WebAppContext}.
	 * @param context the jetty {@link WebAppContext}
	 */
protected final void addDefaultServlet(WebAppContext context) {
    Assert.notNull(context, "Context must not be null");
    ServletHolder holder = new ServletHolder();
    holder.setName("default");
    holder.setClassName("org.eclipse.jetty.servlet.DefaultServlet");
    holder.setInitParameter("dirAllowed", "false");
    holder.setInitOrder(1);
    context.getServletHandler().addServletWithMapping(holder, "/");
    context.getServletHandler().getServletMapping("/").setDefault(true);
}

@Override
public void initialize(final StructrServices services) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
    String sourceJarName = getClass().getProtectionDomain().getCodeSource().getLocation().toString();
    final boolean isTest = Settings.Testing.getValue();
    if (!isTest && StringUtils.stripEnd(sourceJarName, System.getProperty("file.separator")).endsWith("classes")) {
        String jarFile = System.getProperty("jarFile");
        if (StringUtils.isEmpty(jarFile)) {
            throw new IllegalArgumentException(getClass().getName() + " was started in an environment where the classloader cannot determine the JAR file containing the main class.\n" + "Please specify the path to the JAR file in the parameter -DjarFile.\n" + "Example: -DjarFile=${project.build.directory}/${project.artifactId}-${project.version}.jar");
        }
        sourceJarName = jarFile;
    }
    // load configuration from properties file
    maxIdleTime = Services.parseInt(System.getProperty("maxIdleTime"), 30000);
    requestHeaderSize = Services.parseInt(System.getProperty("requestHeaderSize"), 8192);
    if (Settings.Async.getValue()) {
        logger.info("Running in asynchronous mode");
    }
    // other properties
    final String keyStorePath = Settings.KeystorePath.getValue();
    final String keyStorePassword = Settings.KeystorePassword.getValue();
    final String contextPath = System.getProperty("contextPath", "/");
    final boolean enableHttps = Settings.HttpsEnabled.getValue();
    final boolean enableGzipCompression = Settings.GzipCompression.getValue();
    final boolean logRequests = Settings.RequestLogging.getValue();
    final String logPrefix = Settings.LogPrefix.getValue();
    final String host = Settings.ApplicationHost.getValue();
    final int httpsPort = Settings.HttpsPort.getValue();
    boolean enableRewriteFilter = true;
    // get current base path
    String basePath = System.getProperty("home", Settings.getBasePath());
    if (StringUtils.isEmpty(basePath)) {
        // use cwd and, if that fails, /tmp as a fallback
        basePath = System.getProperty("user.dir", "/tmp");
    }
    // create base directory if it does not exist
    final File baseDir = new File(basePath);
    if (!baseDir.exists()) {
        baseDir.mkdirs();
    }
    server = new Server(Settings.HttpPort.getValue());
    final ContextHandlerCollection contexts = new ContextHandlerCollection();
    contexts.addHandler(new DefaultHandler());
    final ServletContextHandler servletContext = new ServletContextHandler(server, contextPath, true, true);
    final List<Connector> connectors = new LinkedList<>();
    // create resource collection from base path & source JAR
    try {
        servletContext.setBaseResource(new ResourceCollection(Resource.newResource(basePath), JarResource.newJarResource(Resource.newResource(sourceJarName))));
    } catch (Throwable t) {
        logger.warn("Base resource {} not usable: {}", new Object[] { basePath, t.getMessage() });
    }
    // this is needed for the filters to work on the root context "/"
    servletContext.addServlet("org.eclipse.jetty.servlet.DefaultServlet", "/");
    servletContext.setInitParameter("org.eclipse.jetty.servlet.Default.dirAllowed", "false");
    if (Settings.ConfigServletEnabled.getValue()) {
        // configuration wizard entry point
        servletContext.addServlet("org.structr.rest.servlet.ConfigServlet", "/structr/config/*");
    }
    // CMIS setup
    if (Settings.CmisEnabled.getValue()) {
        try {
            servletContext.addEventListener(new CmisRepositoryContextListener());
            final ServletHolder cmisAtomHolder = servletContext.addServlet(CmisAtomPubServlet.class.getName(), "/structr/cmis/atom/*");
            cmisAtomHolder.setInitParameter("callContextHandler", BasicAuthCallContextHandler.class.getName());
            cmisAtomHolder.setInitParameter("cmisVersion", "1.1");
            final ServletHolder cmisBrowserHolder = servletContext.addServlet(CmisBrowserBindingServlet.class.getName(), "/structr/cmis/browser/*");
            cmisBrowserHolder.setInitParameter("callContextHandler", BasicAuthCallContextHandler.class.getName());
            cmisBrowserHolder.setInitParameter("cmisVersion", "1.1");
        } catch (Throwable t) {
            logger.warn("Cannot initialize CMIS servlet", t);
        }
    }
    hashSessionManager = new HashSessionManager();
    try {
        hashSessionManager.setStoreDirectory(new File(baseDir + "/sessions"));
    } catch (IOException ex) {
        logger.warn("Could not set custom session manager with session store directory {}/sessions", baseDir);
    }
    servletContext.getSessionHandler().setSessionManager(hashSessionManager);
    if (enableRewriteFilter) {
        final FilterHolder rewriteFilter = new FilterHolder(UrlRewriteFilter.class);
        rewriteFilter.setInitParameter("confPath", "urlrewrite.xml");
        servletContext.addFilter(rewriteFilter, "/*", EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD, DispatcherType.ASYNC));
    }
    if (enableGzipCompression) {
        final FilterHolder gzipFilter = Settings.Async.getValue() ? new FilterHolder(AsyncGzipFilter.class) : new FilterHolder(GzipFilter.class);
        gzipFilter.setInitParameter("mimeTypes", "text/html,text/plain,text/css,text/javascript,application/json");
        gzipFilter.setInitParameter("bufferSize", "32768");
        gzipFilter.setInitParameter("minGzipSize", "256");
        gzipFilter.setInitParameter("deflateCompressionLevel", "9");
        gzipFilter.setInitParameter("methods", "GET,POST,PUT,HEAD,DELETE");
        servletContext.addFilter(gzipFilter, "/*", EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD, DispatcherType.ASYNC));
    }
    contexts.addHandler(servletContext);
    // enable request logging
    if (logRequests) {
        final String etcPath = basePath + "/etc";
        final File etcDir = new File(etcPath);
        if (!etcDir.exists()) {
            etcDir.mkdir();
        }
        final String logbackConfFilePath = basePath + "/etc/logback-access.xml";
        final File logbackConfFile = new File(logbackConfFilePath);
        if (!logbackConfFile.exists()) {
            // synthesize a logback accees log config file
            List<String> config = new LinkedList<>();
            config.add("<configuration>");
            config.add("  <appender name=\"FILE\" class=\"ch.qos.logback.core.rolling.RollingFileAppender\">");
            config.add("    <rollingPolicy class=\"ch.qos.logback.core.rolling.TimeBasedRollingPolicy\">");
            config.add("      <fileNamePattern>logs/" + logPrefix + "-%d{yyyy_MM_dd}.request.log.zip</fileNamePattern>");
            config.add("    </rollingPolicy>");
            config.add("    <encoder>");
            config.add("      <charset>UTF-8</charset>");
            config.add("      <pattern>%h %l %u %t \"%r\" %s %b %n%fullRequest%n%n%fullResponse</pattern>");
            config.add("    </encoder>");
            config.add("  </appender>");
            config.add("  <appender-ref ref=\"FILE\" />");
            config.add("</configuration>");
            try {
                logbackConfFile.createNewFile();
                FileUtils.writeLines(logbackConfFile, "UTF-8", config);
            } catch (IOException ioex) {
                logger.warn("Unable to write logback configuration.", ioex);
            }
        }
        final FilterHolder loggingFilter = new FilterHolder(TeeFilter.class);
        servletContext.addFilter(loggingFilter, "/*", EnumSet.of(DispatcherType.REQUEST, Settings.Async.getValue() ? DispatcherType.ASYNC : DispatcherType.FORWARD));
        loggingFilter.setInitParameter("includes", "");
        final RequestLogHandler requestLogHandler = new RequestLogHandler();
        final String logPath = basePath + "/logs";
        final File logDir = new File(logPath);
        // Create logs directory if not existing
        if (!logDir.exists()) {
            logDir.mkdir();
        }
        final RequestLogImpl requestLog = new RequestLogImpl();
        requestLog.setName("REQUESTLOG");
        requestLogHandler.setRequestLog(requestLog);
        final HandlerCollection handlers = new HandlerCollection();
        handlers.setHandlers(new Handler[] { contexts, requestLogHandler });
        server.setHandler(handlers);
    } else {
        server.setHandler(contexts);
    }
    final List<ContextHandler> resourceHandler = collectResourceHandlers();
    for (ContextHandler contextHandler : resourceHandler) {
        contexts.addHandler(contextHandler);
    }
    final Map<String, ServletHolder> servlets = collectServlets();
    // add servlet elements
    int position = 1;
    for (Map.Entry<String, ServletHolder> servlet : servlets.entrySet()) {
        final ServletHolder servletHolder = servlet.getValue();
        final String path = servlet.getKey();
        servletHolder.setInitOrder(position++);
        logger.info("Adding servlet {} for {}", new Object[] { servletHolder, path });
        servletContext.addServlet(servletHolder, path);
    }
    contexts.addHandler(servletContext);
    if (StringUtils.isNotBlank(host) && Settings.HttpPort.getValue() > -1) {
        httpConfig = new HttpConfiguration();
        httpConfig.setSecureScheme("https");
        httpConfig.setSecurePort(httpsPort);
        //httpConfig.setOutputBufferSize(8192);
        httpConfig.setRequestHeaderSize(requestHeaderSize);
        final ServerConnector httpConnector = new ServerConnector(server, new HttpConnectionFactory(httpConfig));
        httpConnector.setHost(host);
        httpConnector.setPort(Settings.HttpPort.getValue());
        connectors.add(httpConnector);
    } else {
        logger.warn("Unable to configure HTTP server port, please make sure that {} and {} are set correctly in structr.conf.", Settings.ApplicationHost.getKey(), Settings.HttpPort.getKey());
    }
    if (enableHttps) {
        if (httpsPort > -1 && keyStorePath != null && !keyStorePath.isEmpty() && keyStorePassword != null) {
            httpsConfig = new HttpConfiguration(httpConfig);
            httpsConfig.addCustomizer(new SecureRequestCustomizer());
            final SslContextFactory sslContextFactory = new SslContextFactory();
            sslContextFactory.setKeyStorePath(keyStorePath);
            sslContextFactory.setKeyStorePassword(keyStorePassword);
            final ServerConnector https = new ServerConnector(server, new SslConnectionFactory(sslContextFactory, "http/1.1"), new HttpConnectionFactory(httpsConfig));
            https.setPort(httpsPort);
            https.setIdleTimeout(500000);
            https.setHost(host);
            https.setPort(httpsPort);
            connectors.add(https);
        } else {
            logger.warn("Unable to configure SSL, please make sure that {}, {} and {} are set correctly in structr.conf.", new Object[] { Settings.HttpsPort.getKey(), Settings.KeystorePath.getKey(), Settings.KeystorePassword.getKey() });
        }
    }
    if (!connectors.isEmpty()) {
        server.setConnectors(connectors.toArray(new Connector[0]));
    } else {
        logger.error("No connectors configured, aborting.");
        System.exit(0);
    }
    server.setStopTimeout(1000);
    server.setStopAtShutdown(true);
}

public void addWebSocketServlets() {
    // Servlet where the websocket connection is served from.
    ServletHolder wsholder = addServlet("/socket", WaveWebSocketServlet.class);
    // TODO(zamfi): fix to let messages span frames.
    wsholder.setInitParameter("bufferSize", "" + BUFFER_SIZE);
    // Servlet where the websocket connection is served from.
    ServletHolder sioholder = addServlet("/socket.io/*", WaveSocketIOServlet.class);
    // TODO(zamfi): fix to let messages span frames.
    sioholder.setInitParameter("bufferSize", "" + BUFFER_SIZE);
    // Set flash policy server parameters
    String flashPolicyServerHost = "localhost";
    StringBuilder flashPolicyAllowedPorts = new StringBuilder();
    /*
     * Loop through addresses, collect list of ports, and determine if we are to use "localhost"
     * of the AnyHost wildcard.
     */
    for (InetSocketAddress addr : httpAddresses) {
        if (flashPolicyAllowedPorts.length() > 0) {
            flashPolicyAllowedPorts.append(",");
        }
        flashPolicyAllowedPorts.append(addr.getPort());
        if (!addr.getAddress().isLoopbackAddress()) {
            // Until it's possible to pass a list of address, this is the only valid alternative.
            flashPolicyServerHost = "0.0.0.0";
        }
    }
    sioholder.setInitParameter(FlashSocketTransport.PARAM_FLASHPOLICY_SERVER_HOST, flashPolicyServerHost);
    sioholder.setInitParameter(FlashSocketTransport.PARAM_FLASHPOLICY_SERVER_PORT, "" + flashsocketPolicyPort);
    // TODO: Change to use the public http address and all other bound addresses.
    sioholder.setInitParameter(FlashSocketTransport.PARAM_FLASHPOLICY_DOMAIN, "*");
    sioholder.setInitParameter(FlashSocketTransport.PARAM_FLASHPOLICY_PORTS, flashPolicyAllowedPorts.toString());
    // Serve the static content and GWT web client with the default servlet
    // (acts like a standard file-based web server).
    addServlet("/static/*", DefaultServlet.class);
    addServlet("/webclient/*", DefaultServlet.class);
}

public void addWebSocketServlets() {
    // Servlet where the websocket connection is served from.
    ServletHolder wsholder = addServlet("/socket", WaveWebSocketServlet.class);
    // TODO(zamfi): fix to let messages span frames.
    // 1M buffer
    wsholder.setInitParameter("bufferSize", "" + 1024 * 1024);
    // Servlet where the websocket connection is served from.
    ServletHolder sioholder = addServlet("/socket.io/*", WaveSocketIOServlet.class);
    // TODO(zamfi): fix to let messages span frames.
    // 1M buffer
    sioholder.setInitParameter("bufferSize", "" + 1024 * 1024);
    // Set flash policy server parameters
    String flashPolicyServerHost = "localhost";
    StringBuilder flashPolicyAllowedPorts = new StringBuilder();
    /*
     * Loop through addresses, collect list of ports, and determine if we are to use "localhost"
     * of the AnyHost wildcard.
     */
    for (InetSocketAddress addr : httpAddresses) {
        if (flashPolicyAllowedPorts.length() > 0) {
            flashPolicyAllowedPorts.append(",");
        }
        flashPolicyAllowedPorts.append(addr.getPort());
        if (!addr.getAddress().isLoopbackAddress()) {
            // Until it's possible to pass a list of address, this is the only valid alternative.
            flashPolicyServerHost = "0.0.0.0";
        }
    }
    sioholder.setInitParameter(FlashSocketTransport.FLASHPOLICY_SERVER_HOST_KEY, flashPolicyServerHost);
    sioholder.setInitParameter(FlashSocketTransport.FLASHPOLICY_SERVER_PORT_KEY, "" + flashsocketPolicyPort);
    // TODO: Change to use the public http address and all other bound addresses.
    sioholder.setInitParameter(FlashSocketTransport.FLASHPOLICY_DOMAIN_KEY, "*");
    sioholder.setInitParameter(FlashSocketTransport.FLASHPOLICY_PORTS_KEY, flashPolicyAllowedPorts.toString());
    // Serve the static content and GWT web client with the default servlet
    // (acts like a standard file-based web server).
    addServlet("/static/*", DefaultServlet.class);
    addServlet("/webclient/*", DefaultServlet.class);
}

public void addWebSocketServlets() {
    // Servlet where the websocket connection is served from.
    ServletHolder wsholder = addServlet("/socket", WaveWebSocketServlet.class);
    // TODO(zamfi): fix to let messages span frames.
    // 1M buffer
    wsholder.setInitParameter("bufferSize", "" + 1024 * 1024 * 4);
    // Servlet where the websocket connection is served from.
    ServletHolder sioholder = addServlet("/socket.io/*", WaveSocketIOServlet.class);
    // TODO(zamfi): fix to let messages span frames.
    // 1M buffer
    sioholder.setInitParameter("bufferSize", "" + 1024 * 1024);
    // Set flash policy server parameters
    String flashPolicyServerHost = "localhost";
    StringBuilder flashPolicyAllowedPorts = new StringBuilder();
    /*
     * Loop through addresses, collect list of ports, and determine if we are to use "localhost"
     * of the AnyHost wildcard.
     */
    for (InetSocketAddress addr : httpAddresses) {
        if (flashPolicyAllowedPorts.length() > 0) {
            flashPolicyAllowedPorts.append(",");
        }
        flashPolicyAllowedPorts.append(addr.getPort());
        if (!addr.getAddress().isLoopbackAddress()) {
            // Until it's possible to pass a list of address, this is the only valid alternative.
            flashPolicyServerHost = "0.0.0.0";
        }
    }
    sioholder.setInitParameter(FlashSocketTransport.FLASHPOLICY_SERVER_HOST_KEY, flashPolicyServerHost);
    sioholder.setInitParameter(FlashSocketTransport.FLASHPOLICY_SERVER_PORT_KEY, "" + flashsocketPolicyPort);
    // TODO: Change to use the public http address and all other bound addresses.
    sioholder.setInitParameter(FlashSocketTransport.FLASHPOLICY_DOMAIN_KEY, "*");
    sioholder.setInitParameter(FlashSocketTransport.FLASHPOLICY_PORTS_KEY, flashPolicyAllowedPorts.toString());
    // Serve the static content and GWT web client with the default servlet
    // (acts like a standard file-based web server).
    addServlet("/static/*", DefaultServlet.class);
    addServlet("/webclient/*", DefaultServlet.class);
}

private ContextHandler makeContext(final String contextPath, final JettyEnv env, final Config cfg) throws MalformedURLException, IOException {
    final ServletContextHandler app = new ServletContextHandler();
    // This enables the use of sessions in Jetty, feature available
    // for Gerrit plug-ins to enable user-level sessions.
    //
    app.setSessionHandler(new SessionHandler());
    app.setErrorHandler(new HiddenErrorHandler());
    // This is the path we are accessed by clients within our domain.
    //
    app.setContextPath(contextPath);
    // Serve static resources directly from our JAR. This way we don't
    // need to unpack them into yet another temporary directory prior to
    // serving to clients.
    //
    app.setBaseResource(getBaseResource(app));
    // HTTP front-end filter to be used as surrogate of Apache HTTP
    // reverse-proxy filtering.
    // It is meant to be used as simpler tiny deployment of custom-made
    // security enforcement (Security tokens, IP-based security filtering, others)
    String filterClassName = cfg.getString("httpd", null, "filterClass");
    if (filterClassName != null) {
        try {
            @SuppressWarnings("unchecked") Class<? extends Filter> filterClass = (Class<? extends Filter>) Class.forName(filterClassName);
            Filter filter = env.webInjector.getInstance(filterClass);
            app.addFilter(new FilterHolder(filter), "/*", EnumSet.of(DispatcherType.REQUEST, DispatcherType.ASYNC));
        } catch (Throwable e) {
            String errorMessage = "Unable to instantiate front-end HTTP Filter " + filterClassName;
            log.error(errorMessage, e);
            throw new IllegalArgumentException(errorMessage, e);
        }
    }
    // Perform the same binding as our web.xml would do, but instead
    // of using the listener to create the injector pass the one we
    // already have built.
    //
    GuiceFilter filter = env.webInjector.getInstance(GuiceFilter.class);
    app.addFilter(new FilterHolder(filter), "/*", EnumSet.of(DispatcherType.REQUEST, DispatcherType.ASYNC));
    app.addEventListener(new GuiceServletContextListener() {

        @Override
        protected Injector getInjector() {
            return env.webInjector;
        }
    });
    // Jetty requires at least one servlet be bound before it will
    // bother running the filter above. Since the filter has all
    // of our URLs except the static resources, the only servlet
    // we need to bind is the default static resource servlet from
    // the Jetty container.
    //
    final ServletHolder ds = app.addServlet(DefaultServlet.class, "/");
    ds.setInitParameter("dirAllowed", "false");
    ds.setInitParameter("redirectWelcome", "false");
    ds.setInitParameter("useFileMappedBuffer", "false");
    ds.setInitParameter("gzip", "true");
    app.setWelcomeFiles(new String[0]);
    return app;
}

public void addWebSocketServlets() {
    // Servlet where the websocket connection is served from.
    ServletHolder wsholder = addServlet("/socket", WaveWebSocketServlet.class);
    // TODO(zamfi): fix to let messages span frames.
    wsholder.setInitParameter("bufferSize", "" + BUFFER_SIZE);
    // Atmosphere framework. Replacement of Socket.IO
    // See https://issues.apache.org/jira/browse/WAVE-405
    ServletHolder atholder = addServlet("/atmosphere*", AtmosphereGuiceServlet.class);
    // Enable guice. See
    // https://github.com/Atmosphere/atmosphere/wiki/Configuring-Atmosphere%27s-Classes-Creation-and-Injection
    atholder.setInitParameter("org.atmosphere.cpr.objectFactory", "org.waveprotocol.box.server.rpc.atmosphere.GuiceAtmosphereFactory");
    atholder.setAsyncSupported(true);
    atholder.setInitOrder(0);
    // Serve the static content and GWT web client with the default servlet
    // (acts like a standard file-based web server).
    addServlet("/static/*", DefaultServlet.class);
    addServlet("/webclient/*", DefaultServlet.class);
}

public void addWebSocketServlets(WebAppContext context) {
    // Servlet where the websocket connection is served from.
    //ServletHolder wsholder = addServlet("/socket", WaveWebSocketServlet.class);
    Injector injector = (Injector) context.getAttribute(INJECTOR_ATTRIBUTE);
    ServletHolder wsholder = new ServletHolder(new WaveWebSocketServlet(this, injector.getInstance(Key.get(Integer.class, Names.named(CoreSettings.WEBSOCKET_MAX_IDLE_TIME))), injector.getInstance(Key.get(Integer.class, Names.named(CoreSettings.WEBSOCKET_MAX_MESSAGE_SIZE)))));
    context.addServlet(wsholder, "/socket");
    // TODO(zamfi): fix to let messages span frames.
    wsholder.setInitParameter("bufferSize", "" + BUFFER_SIZE);
    // Atmosphere framework. Replacement of Socket.IO
    // See https://issues.apache.org/jira/browse/WAVE-405
    ServletHolder atholder = addServlet("/atmosphere", injector.getInstance(AtmosphereGuiceServlet.class));
    // Enable guice. See
    // https://github.com/Atmosphere/atmosphere/wiki/Configuring-Atmosphere%27s-Classes-Creation-and-Injection
    atholder.setInitParameter("org.atmosphere.cpr.objectFactory", "org.waveprotocol.box.server.rpc.atmosphere.GuiceAtmosphereFactory");
    atholder.setAsyncSupported(true);
    atholder.setInitOrder(0);
    // Serve the static content and GWT web client with the default servlet
    // (acts like a standard file-based web server).
    ServletHolder defaultServlet = new ServletHolder(new DefaultServlet());
    context.addServlet(defaultServlet, "/static/*");
    context.addServlet(defaultServlet, "/webclient/*");
}

/**
   * Add default apps.
   * @param appDir The application directory
   * @throws IOException
   */
protected void addDefaultApps(ContextHandlerCollection parent, final String appDir, Configuration conf) throws IOException {
    // set up the context for "/logs/" if "hadoop.log.dir" property is defined.
    String logDir = this.logDir;
    if (logDir == null) {
        logDir = System.getProperty("hadoop.log.dir");
    }
    if (logDir != null) {
        ServletContextHandler logContext = new ServletContextHandler(parent, "/logs");
        logContext.addServlet(AdminAuthorizedServlet.class, "/*");
        logContext.setResourceBase(logDir);
        if (conf.getBoolean(ServerConfigurationKeys.HBASE_JETTY_LOGS_SERVE_ALIASES, ServerConfigurationKeys.DEFAULT_HBASE_JETTY_LOGS_SERVE_ALIASES)) {
            Map<String, String> params = logContext.getInitParams();
            params.put("org.mortbay.jetty.servlet.Default.aliases", "true");
        }
        logContext.setDisplayName("logs");
        setContextAttributes(logContext, conf);
        addNoCacheFilter(webAppContext);
        defaultContexts.put(logContext, true);
    }
    // set up the context for "/static/*"
    ServletContextHandler staticContext = new ServletContextHandler(parent, "/static");
    staticContext.setResourceBase(appDir + "/static");
    staticContext.addServlet(DefaultServlet.class, "/*");
    staticContext.setDisplayName("static");
    setContextAttributes(staticContext, conf);
    defaultContexts.put(staticContext, true);
}

public void testGzipGet() throws Exception {
    Server server = new Server(getTestRepositoryPort());
    String localRepositoryPath = FileTestUtils.getTestOutputDir().toString();
    ServletContextHandler root = new ServletContextHandler(ServletContextHandler.SESSIONS);
    root.setResourceBase(localRepositoryPath);
    ServletHolder servletHolder = new ServletHolder(new DefaultServlet());
    servletHolder.setInitParameter("gzip", "true");
    root.addServlet(servletHolder, "/*");
    addConnectors(server);
    server.setHandler(root);
    server.start();
    try {
        Wagon wagon = getWagon();
        Repository testRepository = new Repository("id", getRepositoryUrl(server));
        File sourceFile = new File(localRepositoryPath + "/gzip");
        sourceFile.deleteOnExit();
        String resName = "gzip-res.txt";
        String sourceContent = writeTestFileGzip(sourceFile, resName);
        wagon.connect(testRepository);
        File destFile = FileTestUtils.createUniqueFile(getName(), getName());
        destFile.deleteOnExit();
        wagon.get("gzip/" + resName, destFile);
        wagon.disconnect();
        String destContent = FileUtils.fileRead(destFile);
        assertEquals(sourceContent, destContent);
    } finally {
        server.stop();
    }
}

/**
     * {@inheritDoc}
     * 
     * @see net.sourceforge.eclipsejetty.jetty.AbstractWebDefaults#getDefaultServletClass()
     */
@Override
protected String getDefaultServletClass() {
    return "org.eclipse.jetty.servlet.DefaultServlet";
}

ServletContextHandler createServletContext(String path) {
    ensureServer();
    ServletContextHandler result = new ServletContextHandler(getHandlerContainer(), path);
    result.setSessionHandler(sessionHandler);
    result.setBaseResource(createServletContextPath());
    result.addServlet(DefaultServlet.class, "/");
    return result;
}