Java Examples for org.glassfish.grizzly.threadpool.ThreadPoolConfig

public void start(int listenPort, ExecutorService threadpool) throws Exception {
    ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) threadpool;
    ThreadPoolConfig config = ThreadPoolConfig.defaultConfig().copy().setCorePoolSize(threadPoolExecutor.getCorePoolSize()).setMaxPoolSize(threadPoolExecutor.getMaximumPoolSize()).setPoolName("GRIZZLY-SERVER");
    ExecutorService executorService = GrizzlyExecutorService.createInstance(config);
    FilterChainBuilder filterChainBuilder = FilterChainBuilder.stateless();
    filterChainBuilder.add(new TransportFilter());
    filterChainBuilder.add(new GrizzlyProtocolFilter());
    filterChainBuilder.add(new GrizzlyServerHandler(executorService));
    TCPNIOTransportBuilder builder = TCPNIOTransportBuilder.newInstance();
    builder.setOptimizedForMultiplexing(true);
    builder.setIOStrategy(SameThreadIOStrategy.getInstance());
    transport = builder.build();
    transport.setProcessor(filterChainBuilder.build());
    transport.bind(listenPort);
    transport.start();
    LOGGER.warn("server started,listen at: " + listenPort);
}

@Override
protected void configureHttpServer() {
    final Map<String, Object> properties = getApplication().getProperties();
    connectors = Connector.createDefaultConnectors(properties);
    if (connectors.size() == 0) {
        logger.warn(Messages.get("info.connector.none"));
        connectors.add(Connector.createDefault(Maps.newHashMap()));
    }
    List<NetworkListener> listeners = GrizzlyServerUtil.createListeners(connectors, GrizzlyServerUtil.createCompressionConfig("http", properties));
    webSocketEnabled = !"false".equals(properties.get(WebSocketAddon.WEB_SOCKET_ENABLED_CONF));
    final String contextPath = StringUtils.defaultIfBlank((String) properties.get(WEB_SOCKET_CONTEXT_PATH), "/");
    if (webSocketEnabled) {
        GrizzlyServerUtil.bindWebSocket(contextPath, this, listeners);
    }
    String charset = StringUtils.defaultIfBlank((String) properties.get("app.encoding"), "utf-8");
    System.setProperty(Constants.class.getName() + ".default-character-encoding", charset);
    httpServer = new HttpServer() {

        @Override
        public synchronized void start() throws IOException {
            if (webSocketServerContainer != null)
                try {
                    webSocketServerContainer.start(contextPath, -1);
                } catch (DeploymentException e) {
                    logger.error("启动websocket容器失败", e);
                }
            super.start();
        }

        @Override
        public synchronized GrizzlyFuture<HttpServer> shutdown(long gracePeriod, TimeUnit timeUnit) {
            if (webSocketServerContainer != null)
                webSocketServerContainer.stop();
            return super.shutdown(gracePeriod, timeUnit);
        }

        @Override
        public synchronized void shutdownNow() {
            if (webSocketServerContainer != null)
                webSocketServerContainer.stop();
            super.shutdownNow();
        }
    };
    httpServer.getServerConfiguration().setJmxEnabled(getApplication().isJmxEnabled());
    ThreadPoolConfig workerThreadPoolConfig = null;
    String workerThreadPoolConfigClass = Utils.getProperty(properties, WORKER_THREAD_POOL_CONFIG, String.class);
    if (StringUtils.isNotBlank(workerThreadPoolConfigClass)) {
        workerThreadPoolConfig = ClassUtils.newInstance(workerThreadPoolConfigClass);
    }
    ThreadPoolConfig selectorThreadPoolConfig = null;
    String selectorThreadPoolConfigClass = Utils.getProperty(properties, SELECTOR_THREAD_POOL_CONFIG, String.class);
    if (StringUtils.isNotBlank(selectorThreadPoolConfigClass)) {
        selectorThreadPoolConfig = ClassUtils.newInstance(selectorThreadPoolConfigClass);
    }
    TCPNIOTransportBuilder transportBuilder = null;
    if (workerThreadPoolConfig != null || selectorThreadPoolConfig != null) {
        transportBuilder = TCPNIOTransportBuilder.newInstance();
        if (workerThreadPoolConfig != null) {
            transportBuilder.setWorkerThreadPoolConfig(workerThreadPoolConfig);
        }
        if (selectorThreadPoolConfig != null) {
            transportBuilder.setSelectorThreadPoolConfig(selectorThreadPoolConfig);
        }
    }
    Integer selectorSize = Utils.getProperty(properties, SELECTOR_THREAD_POOL_SIZE, Integer.class);
    Integer workerCoreSize = Utils.getProperty(properties, WORKER_THREAD_POOL_CORE_SIZE, Integer.class);
    Integer workerMaxSize = Utils.getProperty(properties, WORKER_THREAD_POOL_MAX_SIZE, Integer.class);
    for (NetworkListener listener : listeners) {
        if (transportBuilder != null) {
            listener.setTransport(transportBuilder.build());
        }
        if (workerThreadPoolConfig == null) {
            TCPNIOTransport transport = listener.getTransport();
            workerThreadPoolConfig = transport.getWorkerThreadPoolConfig();
            boolean change = false;
            if (workerCoreSize != null && workerCoreSize > 0) {
                workerThreadPoolConfig.setCorePoolSize(workerCoreSize);
                change = true;
            }
            if (workerMaxSize != null && workerMaxSize > 0) {
                workerThreadPoolConfig.setMaxPoolSize(workerMaxSize);
                change = true;
            }
            if (change) {
                transport.setWorkerThreadPoolConfig(workerThreadPoolConfig);
            }
        }
        if (selectorThreadPoolConfig == null && selectorSize != null && selectorSize > 0) {
            listener.getTransport().setSelectorRunnersCount(selectorSize);
        }
        httpServer.addListener(listener);
    }
    final ServerConfiguration config = httpServer.getServerConfiguration();
    config.setPassTraceRequest(true);
    config.setHttpServerName(getApplication().getApplicationName());
    String version = getApplication().getApplicationVersion().toString();
    config.setHttpServerVersion(config.getHttpServerName().equals(Application.DEFAULT_APP_NAME) ? Ameba.getVersion() : version);
    config.setName("Ameba-HttpServer-" + getApplication().getApplicationName());
}

private ThreadPoolConfig getWorkerThreadPoolConfig(Map<String, Object> properties) {
    if (properties.containsKey(GrizzlyClientProperties.WORKER_THREAD_POOL_CONFIG)) {
        return Utils.getProperty(properties, GrizzlyClientProperties.WORKER_THREAD_POOL_CONFIG, ThreadPoolConfig.class);
    } else if (properties.containsKey(ClientProperties.WORKER_THREAD_POOL_CONFIG)) {
        Object threadPoolConfig = Utils.getProperty(properties, ClientProperties.WORKER_THREAD_POOL_CONFIG, Object.class);
        if (threadPoolConfig instanceof org.glassfish.tyrus.client.ThreadPoolConfig) {
            org.glassfish.tyrus.client.ThreadPoolConfig clientThreadPoolConfig = (org.glassfish.tyrus.client.ThreadPoolConfig) threadPoolConfig;
            ThreadPoolConfig grizzlyThreadPoolConfig = ThreadPoolConfig.defaultConfig();
            grizzlyThreadPoolConfig.setMaxPoolSize(clientThreadPoolConfig.getMaxPoolSize()).setCorePoolSize(clientThreadPoolConfig.getCorePoolSize()).setPriority(clientThreadPoolConfig.getPriority()).setDaemon(clientThreadPoolConfig.isDaemon()).setKeepAliveTime(clientThreadPoolConfig.getKeepAliveTime(TimeUnit.MILLISECONDS), TimeUnit.MILLISECONDS).setInitialClassLoader(clientThreadPoolConfig.getInitialClassLoader()).setPoolName(clientThreadPoolConfig.getPoolName()).setQueue(clientThreadPoolConfig.getQueue()).setQueueLimit(clientThreadPoolConfig.getQueueLimit()).setThreadFactory(clientThreadPoolConfig.getThreadFactory());
            return grizzlyThreadPoolConfig;
        } else if (threadPoolConfig instanceof ThreadPoolConfig) {
            return (ThreadPoolConfig) threadPoolConfig;
        } else {
            LOGGER.log(Level.CONFIG, String.format("Invalid type of configuration property of %s (%s), %s cannot be cast to %s or %s", ClientProperties.WORKER_THREAD_POOL_CONFIG, threadPoolConfig.toString(), threadPoolConfig.getClass().toString(), ThreadPoolConfig.class.toString(), org.glassfish.tyrus.client.ThreadPoolConfig.class.toString()));
        }
    }
    return null;
}

@Override
protected void doOpen() throws Throwable {
    FilterChainBuilder filterChainBuilder = FilterChainBuilder.stateless();
    filterChainBuilder.add(new TransportFilter());
    filterChainBuilder.add(new GrizzlyCodecAdapter(getCodec(), getUrl(), this));
    filterChainBuilder.add(new GrizzlyHandler(getUrl(), this));
    TCPNIOTransportBuilder builder = TCPNIOTransportBuilder.newInstance();
    ThreadPoolConfig config = builder.getWorkerThreadPoolConfig();
    config.setPoolName(SERVER_THREAD_POOL_NAME).setQueueLimit(-1);
    String threadpool = getUrl().getParameter(Constants.THREADPOOL_KEY, Constants.DEFAULT_THREADPOOL);
    if (Constants.DEFAULT_THREADPOOL.equals(threadpool)) {
        int threads = getUrl().getPositiveParameter(Constants.THREADS_KEY, Constants.DEFAULT_THREADS);
        config.setCorePoolSize(threads).setMaxPoolSize(threads).setKeepAliveTime(0L, TimeUnit.SECONDS);
    } else if ("cached".equals(threadpool)) {
        int threads = getUrl().getPositiveParameter(Constants.THREADS_KEY, Integer.MAX_VALUE);
        config.setCorePoolSize(0).setMaxPoolSize(threads).setKeepAliveTime(60L, TimeUnit.SECONDS);
    } else {
        throw new IllegalArgumentException("Unsupported threadpool type " + threadpool);
    }
    builder.setKeepAlive(true).setReuseAddress(false).setIOStrategy(SameThreadIOStrategy.getInstance());
    transport = builder.build();
    transport.setProcessor(filterChainBuilder.build());
    transport.bind(getBindAddress());
    transport.start();
}

/**
     * Starts Grizzly HTTP server exposing JAX-RS resources defined in this application.
     * @return Grizzly HTTP server.
     */
private static HttpServer startServer(String baseUri) throws IOException {
    final ResourceConfig rc = new ResourceConfig().packages("se252.jan15.calvinandhobbes.project0");
    System.out.println("Trying to starting service at: " + baseUri);
    HttpServer httpServer = GrizzlyHttpServerFactory.createHttpServer(URI.create(baseUri), rc, false);
    TCPNIOTransport transport = getListener(httpServer).getTransport();
    ThreadPoolConfig config = ThreadPoolConfig.defaultConfig().setPoolName("worker-thread-").setCorePoolSize(20).setMaxPoolSize(20).setQueueLimit(-1);
    transport.configureBlocking(false);
    transport.setSelectorRunnersCount(3);
    transport.setWorkerThreadPoolConfig(config);
    transport.setIOStrategy(WorkerThreadIOStrategy.getInstance());
    transport.setTcpNoDelay(true);
    httpServer.start();
    System.out.println("Blocking Transport(T/F): " + transport.isBlocking());
    System.out.println("Num SelectorRunners: " + transport.getSelectorRunnersCount());
    System.out.println("Num WorkerThreads: " + transport.getWorkerThreadPoolConfig().getCorePoolSize());
    return httpServer;
}

private void configureNetworkListener() throws Exception {
    boolean allowPortChange = true;
    NetworkListener listener = this.httpServer.getListener("grizzly");
    if (listener == null) {
        listener = new NetworkListener("grizzly", rexsterServerHost, rexsterServerPort);
        this.httpServer.addListener(listener);
        allowPortChange = false;
    }
    if (allowPortChange && hasPortHostChanged()) {
        listener.getTransport().unbindAll();
        listener.getTransport().bind(rexsterServerHost, rexsterServerPort);
        logger.info(String.format("RexPro Server bound to [%s:%s]", rexsterServerHost, rexsterServerPort));
    }
    if (hasThreadPoolSizeChanged()) {
        final ThreadPoolConfig workerThreadPoolConfig = ThreadPoolConfig.defaultConfig().setCorePoolSize(coreWorkerThreadPoolSize).setMaxPoolSize(maxWorkerThreadPoolSize);
        listener.getTransport().setWorkerThreadPoolConfig(workerThreadPoolConfig);
        final ThreadPoolConfig kernalThreadPoolConfig = ThreadPoolConfig.defaultConfig().setCorePoolSize(coreKernalThreadPoolSize).setMaxPoolSize(maxKernalThreadPoolSize);
        listener.getTransport().setKernelThreadPoolConfig(kernalThreadPoolConfig);
        if (listener.getTransport().getKernelThreadPool() != null) {
            ((GrizzlyExecutorService) listener.getTransport().getKernelThreadPool()).reconfigure(kernalThreadPoolConfig);
        }
        if (listener.getTransport().getWorkerThreadPool() != null) {
            ((GrizzlyExecutorService) listener.getTransport().getWorkerThreadPool()).reconfigure(workerThreadPoolConfig);
        }
        logger.info(String.format("HTTP/REST thread pool configuration: kernal[%s / %s] worker[%s / %s] ", coreKernalThreadPoolSize, maxKernalThreadPoolSize, coreWorkerThreadPoolSize, maxWorkerThreadPoolSize));
    }
    listener.setMaxPostSize(maxPostSize);
    listener.setMaxHttpHeaderSize(maxHeaderSize);
    listener.setUploadTimeout(uploadTimeoutMillis);
    listener.setDisableUploadTimeout(false);
    if (this.hasIoStrategyChanged()) {
        final IOStrategy strategy = GrizzlyIoStrategyFactory.createIoStrategy(this.ioStrategy);
        listener.getTransport().setIOStrategy(strategy);
        logger.info(String.format("Using %s IOStrategy for HTTP/REST.", strategy.getClass().getName()));
    }
}

public ExecutorService getWorkerThreadExecutorService() {
    if (_ioStrategy == IoStrategy.SAME_THREAD) {
        return MoreExecutors.newDirectExecutorService();
    }
    if (_workerThreadExecutionService != null) {
        return _workerThreadExecutionService;
    }
    ThreadPoolConfig workerPoolConfig = getWorkerPoolCfg(_ioStrategy, _serviceName, _workerThreadPoolSize);
    return new FixedThreadPool(workerPoolConfig);
}

public static void main(String[] args) throws Exception {
    System.out.println("Jersey performance test web service application");
    final String jaxRsApp = args.length > 0 ? args[0] : null;
    //noinspection unchecked
    final ResourceConfig resourceConfig = ResourceConfig.forApplicationClass((Class<? extends Application>) Class.forName(jaxRsApp));
    URI baseUri = args.length > 1 ? URI.create(args[1]) : BASE_URI;
    int selectors = args.length > 2 ? Integer.parseInt(args[2]) : DEFAULT_SELECTORS;
    int workers = args.length > 3 ? Integer.parseInt(args[3]) : DEFAULT_WORKERS;
    final HttpServer server = GrizzlyHttpServerFactory.createHttpServer(baseUri, resourceConfig, false);
    final TCPNIOTransport transport = server.getListener("grizzly").getTransport();
    transport.setSelectorRunnersCount(selectors);
    transport.setWorkerThreadPoolConfig(ThreadPoolConfig.defaultConfig().setCorePoolSize(workers).setMaxPoolSize(workers));
    server.start();
    System.out.println(String.format("Application started.\nTry out %s\nHit Ctrl-C to stop it...", baseUri));
    while (server.isStarted()) {
        Thread.sleep(600000);
    }
}

/**
     * See https://grizzly.java.net/coreconfig.html
     * See https://grizzly.java.net/bestpractices.html
     */
private void configureWorkerThreads(@NotNull NetworkListener networkListener) {
    //WorkerThreadIOStrategy is the default anyway.
    //networkListener.getTransport().setIOStrategy(WorkerThreadIOStrategy.getInstance());
    //makes a copy
    ThreadPoolConfig config = ThreadPoolConfig.defaultConfig();
    int numThreads = Runtime.getRuntime().availableProcessors() * 2;
    //setting core and max to the same number is important!
    config.setCorePoolSize(numThreads);
    config.setMaxPoolSize(numThreads);
    //a queue limit is optional but recommended
    config.setQueueLimit(1000);
    networkListener.getTransport().setWorkerThreadPoolConfig(config);
}

private ThreadPoolConfig adjustThreadPool() {
    Integer corePoolSize = 2;
    Integer maxPoolSize = 8;
    ThreadPoolConfig workerPoolConfig = ThreadPoolConfig.defaultConfig();
    workerPoolConfig.setCorePoolSize(corePoolSize);
    workerPoolConfig.setMaxPoolSize(maxPoolSize);
    workerPoolConfig.setPoolName("Worker");
    return workerPoolConfig;
}

public boolean start(int httpPort, Integer sslPort) throws IOException {
    Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
    ConfigurableApplicationContext ctx = initSpringApplicationContext();
    if (ctx == null) {
        log.warn("Failed to initialise spring");
        return false;
    }
    complexAppExecutorService = GrizzlyExecutorService.createInstance(ThreadPoolConfig.defaultConfig().copy().setCorePoolSize(5).setMaxPoolSize(5));
    String host = getPropertyOrDefault("host", null);
    int port = getPropertyOrDefaultInt("port", 8080);
    int secureHttpPort = getPropertyOrDefaultInt(MiltonSNIService.SYS_SECURE_PORT, MiltonSNIService.SECURE_PORT);
    if (host == null) {
        httpServer = HttpServer.createSimpleServer(null, port);
    } else {
        httpServer = HttpServer.createSimpleServer(null, host, port);
    }
    // Start the Kademi SNI SSL service
    {
        // TODO: allow injection
        MiltonSNICertificateStore store = null;
        MiltonSNICertificateManager sniCerManager = new MiltonSNICertificateManager(store);
        SSLEngineConfigurator sniConfig = sniCerManager.createEngineConfigurator();
        this.kademiSNIService = new MiltonSNIService(secureHttpPort, sniConfig);
        this.kademiSNIService.startOn(httpServer);
    }
    httpServer.getServerConfiguration().addHttpHandler(new HttpHandler() {

        @Override
        public void service(final Request request, final Response response) throws Exception {
            log.trace("service");
            response.suspend();
            complexAppExecutorService.execute(new Runnable() {

                @Override
                public void run() {
                    try {
                        forwardToCluster(request, response);
                    } finally {
                        response.resume();
                    }
                }
            });
        }
    }, "/");
    httpServer.start();
    running = true;
    return true;
}

protected void configureTransport(final NetworkListener networkListener, final Transport transportConfig, final FilterChainBuilder filterChainBuilder) {
    final String transportClassName = transportConfig.getClassname();
    if (TCPNIOTransport.class.getName().equals(transportClassName)) {
        transport = configureTCPTransport(transportConfig);
    } else if (UDPNIOTransport.class.getName().equals(transportClassName)) {
        transport = configureUDPTransport();
    } else {
        throw new GrizzlyConfigException("Unsupported transport type " + transportConfig.getName());
    }
    String selectorName = transportConfig.getSelectionKeyHandler();
    if (selectorName != null) {
        if (getSelectionKeyHandlerByName(selectorName, transportConfig) != null) {
            if (LOGGER.isLoggable(Level.INFO)) {
                LOGGER.warning("Element, selection-key-handler, has been deprecated and is effectively ignored by the runtime.");
            }
        }
    }
    if (!Transport.BYTE_BUFFER_TYPE.equalsIgnoreCase(transportConfig.getByteBufferType())) {
        transport.setMemoryManager(new ByteBufferManager(true, AbstractMemoryManager.DEFAULT_MAX_BUFFER_SIZE, ByteBufferManager.DEFAULT_SMALL_BUFFER_SIZE));
    }
    final int acceptorThreads = Integer.parseInt(transportConfig.getAcceptorThreads());
    transport.setSelectorRunnersCount(acceptorThreads);
    final int readSize = Integer.parseInt(transportConfig.getSocketReadBufferSize());
    if (readSize > 0) {
        transport.setReadBufferSize(readSize);
    }
    final int writeSize = Integer.parseInt(transportConfig.getSocketWriteBufferSize());
    if (writeSize > 0) {
        transport.setWriteBufferSize(writeSize);
    }
    final ThreadPoolConfig kernelThreadPoolConfig = transport.getKernelThreadPoolConfig();
    kernelThreadPoolConfig.setPoolName(networkListener.getName() + "-kernel");
    if (acceptorThreads > 0) {
        kernelThreadPoolConfig.setCorePoolSize(acceptorThreads).setMaxPoolSize(acceptorThreads);
    }
    transport.setIOStrategy(loadIOStrategy(transportConfig.getIoStrategy()));
    transport.setNIOChannelDistributor(new RoundRobinConnectionDistributor(transport, Boolean.parseBoolean(transportConfig.getDedicatedAcceptorEnabled())));
    filterChainBuilder.add(new TransportFilter());
}

private void start() {
    FilterChainBuilder clientChainBuilder = FilterChainBuilder.stateless();
    clientChainBuilder.add(new TransportFilter());
    clientChainBuilder.add(new RpbFilter(heap));
    clientChainBuilder.add(new PendingRequestFilter());
    filterChain = clientChainBuilder.build();
    transport.setKeepAlive(true);
    transport.setTcpNoDelay(true);
    ThreadPoolConfig config = ThreadPoolConfig.defaultConfig().setPoolName("riak-async-client").setCorePoolSize(PROCESSORS).setMaxPoolSize(PROCESSORS).setKeepAliveTime(timeout, TimeUnit.SECONDS);
    transport.setWorkerThreadPoolConfig(config);
    transport.setIOStrategy(WorkerThreadIOStrategy.getInstance());
    transport.setProcessor(filterChain);
    try {
        transport.start();
        connection = getConnection();
    } catch (IOException e) {
        errorHandler.handleError(e);
    } catch (InterruptedException e) {
        errorHandler.handleError(e);
    } catch (ExecutionException e) {
        errorHandler.handleError(e);
    } catch (TimeoutException e) {
        errorHandler.handleError(e);
    }
}

private void setThreadSize() {
    int threadSize = getThreadSizeFromSystemProperties();
    java.util.Collection<org.glassfish.grizzly.http.server.NetworkListener> listeners = httpServer.getListeners();
    for (org.glassfish.grizzly.http.server.NetworkListener listener : listeners) {
        listener.getTransport().getKernelThreadPoolConfig();
        org.glassfish.grizzly.nio.transport.TCPNIOTransportBuilder builder = org.glassfish.grizzly.nio.transport.TCPNIOTransportBuilder.newInstance();
        org.glassfish.grizzly.threadpool.ThreadPoolConfig config = builder.getWorkerThreadPoolConfig();
        config.setCorePoolSize(threadSize);
        config.setMaxPoolSize(threadSize);
        org.glassfish.grizzly.nio.transport.TCPNIOTransport transport = builder.build();
        listener.setTransport(transport);
    }
    logger.info("thread size set as {}", threadSize);
}

protected void configureTransport(final NetworkListener networkListener, final Transport transportConfig, final FilterChainBuilder filterChainBuilder) {
    final String transportClassName = transportConfig.getClassname();
    if (TCPNIOTransport.class.getName().equals(transportClassName)) {
        transport = configureTCPTransport(transportConfig);
    } else if (UDPNIOTransport.class.getName().equals(transportClassName)) {
        transport = configureUDPTransport();
    } else {
        throw new GrizzlyConfigException("Unsupported transport type " + transportConfig.getName());
    }
    String selectorName = transportConfig.getSelectionKeyHandler();
    if (selectorName != null) {
        if (getSelectionKeyHandlerByName(selectorName, transportConfig) != null) {
            if (LOGGER.isLoggable(Level.INFO)) {
                LOGGER.warning("Element, selection-key-handler, has been deprecated and is effectively ignored by the runtime.");
            }
        }
    }
    if (!Transport.BYTE_BUFFER_TYPE.equalsIgnoreCase(transportConfig.getByteBufferType())) {
        transport.setMemoryManager(new ByteBufferManager(true, AbstractMemoryManager.DEFAULT_MAX_BUFFER_SIZE, ByteBufferManager.DEFAULT_SMALL_BUFFER_SIZE));
    }
    final int acceptorThreads = Integer.parseInt(transportConfig.getAcceptorThreads());
    transport.setSelectorRunnersCount(acceptorThreads);
    final int readSize = Integer.parseInt(transportConfig.getSocketReadBufferSize());
    if (readSize > 0) {
        transport.setReadBufferSize(readSize);
    }
    final int writeSize = Integer.parseInt(transportConfig.getSocketWriteBufferSize());
    if (writeSize > 0) {
        transport.setWriteBufferSize(writeSize);
    }
    final ThreadPoolConfig kernelThreadPoolConfig = transport.getKernelThreadPoolConfig();
    kernelThreadPoolConfig.setPoolName(networkListener.getName() + "-kernel");
    if (acceptorThreads > 0) {
        kernelThreadPoolConfig.setCorePoolSize(acceptorThreads).setMaxPoolSize(acceptorThreads);
    }
    transport.setIOStrategy(loadIOStrategy(transportConfig.getIoStrategy()));
    transport.setNIOChannelDistributor(new RoundRobinConnectionDistributor(transport, Boolean.parseBoolean(transportConfig.getDedicatedAcceptorEnabled())));
    filterChainBuilder.add(new TransportFilter());
}

@Override
protected void doOpen() throws Throwable {
    FilterChainBuilder filterChainBuilder = FilterChainBuilder.stateless();
    filterChainBuilder.add(new TransportFilter());
    filterChainBuilder.add(new GrizzlyCodecAdapter(getCodec(), getUrl(), this));
    filterChainBuilder.add(new GrizzlyHandler(getUrl(), this));
    TCPNIOTransportBuilder builder = TCPNIOTransportBuilder.newInstance();
    ThreadPoolConfig config = builder.getWorkerThreadPoolConfig();
    config.setPoolName(SERVER_THREAD_POOL_NAME).setQueueLimit(-1);
    String threadpool = getUrl().getParameter(Constants.THREADPOOL_KEY, Constants.DEFAULT_THREADPOOL);
    if (Constants.DEFAULT_THREADPOOL.equals(threadpool)) {
        int threads = getUrl().getPositiveParameter(Constants.THREADS_KEY, Constants.DEFAULT_THREADS);
        config.setCorePoolSize(threads).setMaxPoolSize(threads).setKeepAliveTime(0L, TimeUnit.SECONDS);
    } else if ("cached".equals(threadpool)) {
        int threads = getUrl().getPositiveParameter(Constants.THREADS_KEY, Integer.MAX_VALUE);
        config.setCorePoolSize(0).setMaxPoolSize(threads).setKeepAliveTime(60L, TimeUnit.SECONDS);
    } else {
        throw new IllegalArgumentException("Unsupported threadpool type " + threadpool);
    }
    builder.setKeepAlive(true).setReuseAddress(false).setIOStrategy(SameThreadIOStrategy.getInstance());
    transport = builder.build();
    transport.setProcessor(filterChainBuilder.build());
    transport.bind(getBindAddress());
    transport.start();
}

public void start(String[] args) {
    /* CONFIGURE LOGGING */
    // Remove existing handlers attached to the j.u.l root logger
    // (since SLF4J 1.6.5)
    SLF4JBridgeHandler.removeHandlersForRootLogger();
    // Bridge j.u.l (used by Jersey) to the SLF4J root logger
    SLF4JBridgeHandler.install();
    /* CONFIGURE GRIZZLY SERVER */
    LOG.info("Starting OTP Grizzly server...");
    if (args.length > 2)
        port = Integer.parseInt(args[2]);
    // Rather than use Jersey's GrizzlyServerFactory we will construct one manually, so we can
    // set the number of threads, etc.
    HttpServer httpServer = new HttpServer();
    NetworkListener networkListener = new NetworkListener("sample-listener", "localhost", port);
    ThreadPoolConfig threadPoolConfig = ThreadPoolConfig.defaultConfig().setCorePoolSize(1).setMaxPoolSize(Runtime.getRuntime().availableProcessors());
    networkListener.getTransport().setWorkerThreadPoolConfig(threadPoolConfig);
    httpServer.addListener(networkListener);
    ResourceConfig rc = new PackagesResourceConfig("org.opentripplanner");
    // DelegatingFilterProxy.class.getName() does not seem to work out of the box.
    // Register a custom authentication filter, a filter that removes the /ws/ from OTP
    // REST API calls, and a filter that wraps JSON in method calls as needed.
    rc.getProperties().put(ResourceConfig.PROPERTY_CONTAINER_REQUEST_FILTERS, new String[] { AuthFilter.class.getName(), RewriteFilter.class.getName() });
    rc.getProperties().put(ResourceConfig.PROPERTY_CONTAINER_RESPONSE_FILTERS, new String[] { JsonpFilter.class.getName() });
    // Make a factory that hands Jersey OTP modules to inject
    IoCComponentProviderFactory ioc_factory = OTPConfigurator.fromCommandLineArguments(args);
    /* ADD A COUPLE OF HANDLERS (~SERVLETS) */
    // 1. A Grizzly wrapper around the Jersey WebApplication. 
    //    We cannot set the context path to /opentripplanner-api-webapp/ws
    //    https://java.net/jira/browse/GRIZZLY-1481?focusedCommentId=360385&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#action_360385
    HttpHandler handler = ContainerFactory.createContainer(HttpHandler.class, rc, ioc_factory);
    httpServer.getServerConfiguration().addHttpHandler(handler, "/opentripplanner-api-webapp/");
    // 2. A static content server for the client JS apps etc.
    //    This is a filesystem path, not classpath.
    //    Files are relative to the project dir, so
    //    from ./ we can reach e.g. target/classes/data-sources.xml
    staticContentDirectory = "../opentripplanner-leaflet-client/src/main/webapp/";
    httpServer.getServerConfiguration().addHttpHandler(new StaticHttpHandler(staticContentDirectory), "/");
    /* RELINQUISH CONTROL TO THE SERVER THREAD */
    try {
        httpServer.start();
        LOG.info("Grizzly server running.");
        Thread.currentThread().join();
    } catch (BindException be) {
        LOG.error("Cannot bind to port {}. Is it already in use?", port);
    } catch (IOException ioe) {
        LOG.error("IO exception while starting server.");
    } catch (InterruptedException ie) {
        httpServer.stop();
    }
}

public void run() {
    /* Rather than use Jersey's GrizzlyServerFactory we will construct one manually, so we can
           set the number of threads, etc. */
    LOG.info("Starting OTP Grizzly server on port {} using graphs at {}", params.port, params.graphDirectory);
    HttpServer httpServer = new HttpServer();
    NetworkListener networkListener = new NetworkListener("otp_listener", "localhost", params.port);
    ThreadPoolConfig threadPoolConfig = ThreadPoolConfig.defaultConfig().setCorePoolSize(1).setMaxPoolSize(Runtime.getRuntime().availableProcessors());
    networkListener.getTransport().setWorkerThreadPoolConfig(threadPoolConfig);
    httpServer.addListener(networkListener);
    ResourceConfig rc = new PackagesResourceConfig("org.opentripplanner");
    /* DelegatingFilterProxy.class.getName() does not seem to work out of the box.
           Register a custom authentication filter, a filter that removes the /ws/ from OTP
           REST API calls, and a filter that wraps JSON in method calls as needed. */
    rc.getProperties().put(ResourceConfig.PROPERTY_CONTAINER_REQUEST_FILTERS, new String[] { AuthFilter.class.getName(), RewriteFilter.class.getName() });
    rc.getProperties().put(ResourceConfig.PROPERTY_CONTAINER_RESPONSE_FILTERS, new String[] { JsonpFilter.class.getName() });
    /* ADD A COUPLE OF HANDLERS (~= SERVLETS) */
    /* 1. A Grizzly wrapper around the Jersey WebApplication. 
              We cannot set the context path to /opentripplanner-api-webapp/ws
              https://java.net/jira/browse/GRIZZLY-1481?focusedCommentId=360385&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#action_360385 */
    HttpHandler handler = ContainerFactory.createContainer(HttpHandler.class, rc, iocFactory);
    httpServer.getServerConfiguration().addHttpHandler(handler, "/opentripplanner-api-webapp/");
    /* 2. A static content server for the client JS apps etc.
              This is a filesystem path, not classpath. Files are relative to the project dir, so
              from ./ we can reach e.g. target/classes/data-sources.xml */
    HttpHandler staticHandler = makeClientStaticHandler();
    httpServer.getServerConfiguration().addHttpHandler(staticHandler, "/");
    /* RELINQUISH CONTROL TO THE SERVER THREAD */
    try {
        httpServer.start();
        LOG.info("Grizzly server running.");
        Thread.currentThread().join();
    } catch (BindException be) {
        LOG.error("Cannot bind to port {}. Is it already in use?", params.port);
    } catch (IOException ioe) {
        LOG.error("IO exception while starting server.");
    } catch (InterruptedException ie) {
        LOG.info("Interrupted, shutting down.");
        httpServer.stop();
    }
}

/**
     * This function goes through roughly the same steps as Jersey's GrizzlyServerFactory, but we instead construct
     * an HttpServer and NetworkListener manually so we can set the number of threads and other details.
     */
public void run() {
    LOG.info("Starting OTP Grizzly server on ports {} (HTTP) and {} (HTTPS) of interface {}", params.port, params.securePort, params.bindAddress);
    LOG.info("OTP server base path is {}", params.basePath);
    HttpServer httpServer = new HttpServer();
    /* Configure SSL */
    SSLContextConfigurator sslConfig = new SSLContextConfigurator();
    sslConfig.setKeyStoreFile(new File(params.basePath, "keystore").getAbsolutePath());
    sslConfig.setKeyStorePass("opentrip");
    /* OTP is CPU-bound, so we want only as many worker threads as we have cores. */
    ThreadPoolConfig threadPoolConfig = ThreadPoolConfig.defaultConfig().setCorePoolSize(1).setMaxPoolSize(Runtime.getRuntime().availableProcessors());
    /* HTTP (non-encrypted) listener */
    NetworkListener httpListener = new NetworkListener("otp_insecure", params.bindAddress, params.port);
    // OTP is CPU-bound, we don't want more threads than cores. TODO: We should switch to async handling.
    httpListener.setSecure(false);
    /* HTTPS listener */
    NetworkListener httpsListener = new NetworkListener("otp_secure", params.bindAddress, params.securePort);
    // Ideally we'd share the threads between HTTP and HTTPS.
    httpsListener.setSecure(true);
    httpsListener.setSSLEngineConfig(new SSLEngineConfigurator(sslConfig).setClientMode(false).setNeedClientAuth(false));
    // For both HTTP and HTTPS listeners: enable gzip compression, set thread pool, add listener to httpServer.
    for (NetworkListener listener : new NetworkListener[] { httpListener, httpsListener }) {
        CompressionConfig cc = listener.getCompressionConfig();
        cc.setCompressionMode(CompressionConfig.CompressionMode.ON);
        // the min number of bytes to compress
        cc.setCompressionMinSize(50000);
        // the mime types to compress
        cc.setCompressableMimeTypes("application/json", "text/json");
        listener.getTransport().setWorkerThreadPoolConfig(threadPoolConfig);
        httpServer.addListener(listener);
    }
    /* Add a few handlers (~= servlets) to the Grizzly server. */
    /* 1. A Grizzly wrapper around the Jersey Application. */
    Application app = new OTPApplication(server, !params.insecure);
    HttpHandler dynamicHandler = ContainerFactory.createContainer(HttpHandler.class, app);
    httpServer.getServerConfiguration().addHttpHandler(dynamicHandler, "/otp/");
    /* 2. A static content handler to serve the client JS apps etc. from the classpath. */
    CLStaticHttpHandler staticHandler = new CLStaticHttpHandler(GrizzlyServer.class.getClassLoader(), "/client/");
    if (params.disableFileCache) {
        LOG.info("Disabling HTTP server static file cache.");
        staticHandler.setFileCacheEnabled(false);
    }
    httpServer.getServerConfiguration().addHttpHandler(staticHandler, "/");
    /*
         * 3. A static content handler to serve local files from the filesystem, under the "local"
         * path.
         */
    if (params.clientDirectory != null) {
        StaticHttpHandler localHandler = new StaticHttpHandler(params.clientDirectory.getAbsolutePath());
        localHandler.setFileCacheEnabled(false);
        httpServer.getServerConfiguration().addHttpHandler(localHandler, "/local");
    }
    /* 3. Test alternate method (no Jersey). */
    // As in servlets, * is needed in base path to identify the "rest" of the path.
    // GraphService gs = (GraphService) iocFactory.getComponentProvider(GraphService.class).getInstance();
    // Graph graph = gs.getGraph();
    // httpServer.getServerConfiguration().addHttpHandler(new OTPHttpHandler(graph), "/test/*");
    // Add shutdown hook to gracefully shut down Grizzly.
    // Signal handling (sun.misc.Signal) is potentially not available on all JVMs.
    Thread shutdownThread = new Thread(httpServer::shutdown);
    Runtime.getRuntime().addShutdownHook(shutdownThread);
    /* RELINQUISH CONTROL TO THE SERVER THREAD */
    try {
        httpServer.start();
        LOG.info("Grizzly server running.");
        Thread.currentThread().join();
    } catch (BindException be) {
        LOG.error("Cannot bind to port {}. Is it already in use?", params.port);
    } catch (IOException ioe) {
        LOG.error("IO exception while starting server.");
    } catch (InterruptedException ie) {
        LOG.info("Interrupted, shutting down.");
    }
    // Clean up graceful shutdown hook before shutting down Grizzly.
    Runtime.getRuntime().removeShutdownHook(shutdownThread);
    httpServer.shutdown();
}

public boolean start(int httpPort, Integer sslPort) throws IOException {
    Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
    ConfigurableApplicationContext ctx = initSpringApplicationContext();
    if (ctx == null) {
        log.warn("Failed to initialise spring");
        return false;
    }
    complexAppExecutorService = GrizzlyExecutorService.createInstance(ThreadPoolConfig.defaultConfig().copy().setCorePoolSize(5).setMaxPoolSize(5));
    String host = getPropertyOrDefault("host", null);
    int port = getPropertyOrDefaultInt("port", 8080);
    int secureHttpPort = getPropertyOrDefaultInt(MiltonSNIService.SYS_SECURE_PORT, MiltonSNIService.SECURE_PORT);
    if (host == null) {
        httpServer = HttpServer.createSimpleServer(null, port);
    } else {
        httpServer = HttpServer.createSimpleServer(null, host, port);
    }
    // Start the Kademi SNI SSL service
    {
        // TODO: allow injection
        MiltonSNICertificateStore store = null;
        MiltonSNICertificateManager sniCerManager = new MiltonSNICertificateManager(store);
        SSLEngineConfigurator sniConfig = sniCerManager.createEngineConfigurator();
        this.kademiSNIService = new MiltonSNIService(secureHttpPort, sniConfig);
        this.kademiSNIService.startOn(httpServer);
    }
    httpServer.getServerConfiguration().addHttpHandler(new HttpHandler() {

        @Override
        public void service(final Request request, final Response response) throws Exception {
            log.trace("service");
            response.suspend();
            complexAppExecutorService.execute(new Runnable() {

                @Override
                public void run() {
                    try {
                        forwardToCluster(request, response);
                    } finally {
                        response.resume();
                    }
                }
            });
        }
    }, "/");
    httpServer.start();
    running = true;
    return true;
}

/**
     * This function goes through roughly the same steps as Jersey's GrizzlyServerFactory, but we instead construct
     * an HttpServer and NetworkListener manually so we can set the number of threads and other details.
     */
public void run() {
    LOG.info("Starting OTP Grizzly server on ports {} (HTTP) and {} (HTTPS) of interface {}", params.port, params.securePort, params.bindAddress);
    LOG.info("OTP server base path is {}", params.basePath);
    HttpServer httpServer = new HttpServer();
    /* Configure SSL */
    SSLContextConfigurator sslConfig = new SSLContextConfigurator();
    sslConfig.setKeyStoreFile(new File(params.basePath, "keystore").getAbsolutePath());
    sslConfig.setKeyStorePass("opentrip");
    /* OTP is CPU-bound, so we want only as many worker threads as we have cores. */
    ThreadPoolConfig threadPoolConfig = ThreadPoolConfig.defaultConfig().setCorePoolSize(1).setMaxPoolSize(Runtime.getRuntime().availableProcessors());
    /* HTTP (non-encrypted) listener */
    NetworkListener httpListener = new NetworkListener("otp_insecure", params.bindAddress, params.port);
    // OTP is CPU-bound, we don't want more threads than cores. TODO: We should switch to async handling.
    httpListener.setSecure(false);
    /* HTTPS listener */
    NetworkListener httpsListener = new NetworkListener("otp_secure", params.bindAddress, params.securePort);
    // Ideally we'd share the threads between HTTP and HTTPS.
    httpsListener.setSecure(true);
    httpsListener.setSSLEngineConfig(new SSLEngineConfigurator(sslConfig).setClientMode(false).setNeedClientAuth(false));
    // For both HTTP and HTTPS listeners: enable gzip compression, set thread pool, add listener to httpServer.
    for (NetworkListener listener : new NetworkListener[] { httpListener, httpsListener }) {
        CompressionConfig cc = listener.getCompressionConfig();
        cc.setCompressionMode(CompressionConfig.CompressionMode.ON);
        // the min number of bytes to compress
        cc.setCompressionMinSize(50000);
        // the mime types to compress
        cc.setCompressableMimeTypes("application/json", "text/json");
        listener.getTransport().setWorkerThreadPoolConfig(threadPoolConfig);
        httpServer.addListener(listener);
    }
    /* Add a few handlers (~= servlets) to the Grizzly server. */
    /* 1. A Grizzly wrapper around the Jersey Application. */
    Application app = new OTPApplication(server, !params.insecure);
    HttpHandler dynamicHandler = ContainerFactory.createContainer(HttpHandler.class, app);
    httpServer.getServerConfiguration().addHttpHandler(dynamicHandler, "/otp/");
    /* 2. A static content handler to serve the client JS apps etc. from the classpath. */
    CLStaticHttpHandler staticHandler = new CLStaticHttpHandler(GrizzlyServer.class.getClassLoader(), "/client/");
    if (params.disableFileCache) {
        LOG.info("Disabling HTTP server static file cache.");
        staticHandler.setFileCacheEnabled(false);
    }
    httpServer.getServerConfiguration().addHttpHandler(staticHandler, "/");
    /*
         * 3. A static content handler to serve local files from the filesystem, under the "local"
         * path.
         */
    if (params.clientDirectory != null) {
        StaticHttpHandler localHandler = new StaticHttpHandler(params.clientDirectory.getAbsolutePath());
        localHandler.setFileCacheEnabled(false);
        httpServer.getServerConfiguration().addHttpHandler(localHandler, "/local");
    }
    /* 3. Test alternate method (no Jersey). */
    // As in servlets, * is needed in base path to identify the "rest" of the path.
    // GraphService gs = (GraphService) iocFactory.getComponentProvider(GraphService.class).getInstance();
    // Graph graph = gs.getGraph();
    // httpServer.getServerConfiguration().addHttpHandler(new OTPHttpHandler(graph), "/test/*");
    // Add shutdown hook to gracefully shut down Grizzly.
    // Signal handling (sun.misc.Signal) is potentially not available on all JVMs.
    Thread shutdownThread = new Thread(httpServer::shutdown);
    Runtime.getRuntime().addShutdownHook(shutdownThread);
    /* RELINQUISH CONTROL TO THE SERVER THREAD */
    try {
        httpServer.start();
        LOG.info("Grizzly server running.");
        Thread.currentThread().join();
    } catch (BindException be) {
        LOG.error("Cannot bind to port {}. Is it already in use?", params.port);
    } catch (IOException ioe) {
        LOG.error("IO exception while starting server.");
    } catch (InterruptedException ie) {
        LOG.info("Interrupted, shutting down.");
    }
    // Clean up graceful shutdown hook before shutting down Grizzly.
    Runtime.getRuntime().removeShutdownHook(shutdownThread);
    httpServer.shutdown();
}

private void setThreadSize() {
    int threadSize = getThreadSizeFromSystemProperties();
    java.util.Collection<org.glassfish.grizzly.http.server.NetworkListener> listeners = httpServer.getListeners();
    for (org.glassfish.grizzly.http.server.NetworkListener listener : listeners) {
        listener.getTransport().getKernelThreadPoolConfig();
        org.glassfish.grizzly.nio.transport.TCPNIOTransportBuilder builder = org.glassfish.grizzly.nio.transport.TCPNIOTransportBuilder.newInstance();
        org.glassfish.grizzly.threadpool.ThreadPoolConfig config = builder.getWorkerThreadPoolConfig();
        config.setCorePoolSize(threadSize);
        config.setMaxPoolSize(threadSize);
        org.glassfish.grizzly.nio.transport.TCPNIOTransport transport = builder.build();
        listener.setTransport(transport);
    }
    logger.info("thread size set as {}", threadSize);
}

@Override
protected ThreadPoolConfig configureThreadPoolConfig(final NetworkListener networkListener, final ThreadPool threadPool) {
    final ThreadPoolConfig config = super.configureThreadPoolConfig(networkListener, threadPool);
    config.getInitialMonitoringConfig().addProbes(new ThreadPoolMonitor(grizzlyService.getMonitoring(), name, config));
    return config;
}