Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
package org.opentripplanner.standalone.server;
import org.glassfish.grizzly.http.CompressionConfig;
import org.glassfish.grizzly.http.server.CLStaticHttpHandler;
import org.glassfish.grizzly.http.server.HttpHandler;
import org.glassfish.grizzly.http.server.HttpServer;
import org.glassfish.grizzly.http.server.NetworkListener;
import org.glassfish.grizzly.http.server.StaticHttpHandler;
import org.glassfish.grizzly.ssl.SSLContextConfigurator;
import org.glassfish.grizzly.ssl.SSLEngineConfigurator;
import org.glassfish.grizzly.threadpool.ThreadPoolConfig;
import org.glassfish.jersey.server.ContainerFactory;
import org.opentripplanner.standalone.config.CommandLineParameters;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.bridge.SLF4JBridgeHandler;
import javax.ws.rs.core.Application;
import java.io.File;
import java.io.IOException;
import java.net.BindException;
public class GrizzlyServer {
private static final Logger LOG = LoggerFactory.getLogger(GrizzlyServer.class);
private static final int MIN_THREADS = 4;
static {
// Remove existing handlers attached to the j.u.l root logger
SLF4JBridgeHandler.removeHandlersForRootLogger(); // (since SLF4J 1.6.5)
// Bridge j.u.l (used by Jersey) to the SLF4J root logger
SLF4JBridgeHandler.install();
}
/** The command line parameters, including things like port number and content directories. */
private CommandLineParameters params;
private Application app;
/** Construct a Grizzly server with the given IoC injector and command line parameters. */
public GrizzlyServer (CommandLineParameters params, Application app) {
this.params = params;
this.app = app;
}
/**
* OTP is CPU-bound, so we want roughly as many worker threads as we have cores, subject to some constraints.
*/
private int getMaxThreads() {
int maxThreads = Runtime.getRuntime().availableProcessors();
LOG.info("Java reports that this machine has {} available processors.", maxThreads);
// Testing shows increased throughput up to 1.25x as many threads as cores
maxThreads *= 1.25;
if (params.maxThreads != null) {
maxThreads = params.maxThreads;
LOG.info("Based on configuration, forced max thread pool size to {} threads.", maxThreads);
}
if (maxThreads < MIN_THREADS) {
// Some machines apparently report 1 processor even when they have 8.
maxThreads = MIN_THREADS;
}
LOG.info("Maximum HTTP handler thread pool size will be {} threads.", maxThreads);
return maxThreads;
}
/**
* 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 directory is: {}", params.baseDirectory);
HttpServer httpServer = new HttpServer();
/* Configure SSL FIXME OTP2 where will we store they keyfile? */
SSLContextConfigurator sslConfig = new SSLContextConfigurator();
sslConfig.setKeyStoreFile(new File(params.getBaseDirectory(), "keystore").getAbsolutePath());
sslConfig.setKeyStorePass("opentrip");
// Set up a pool of threads to handle incoming HTTP requests.
// According to the Grizzly docs, setting the core and max pool size equal with no queue limit
// will use a more efficient fixed-size thread pool implementation.
// TODO we should probably use Grizzly async processing rather than tying up the HTTP handler threads.
int nHandlerThreads = getMaxThreads();
ThreadPoolConfig threadPoolConfig = ThreadPoolConfig.defaultConfig()
.setCorePoolSize(nHandlerThreads)
.setMaxPoolSize(nHandlerThreads)
.setQueueLimit(-1);
/* HTTP (non-encrypted) listener */
NetworkListener httpListener = new NetworkListener("otp_insecure", params.bindAddress, params.port);
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);
cc.setCompressionMinSize(50000); // the min number of bytes to compress
cc.setCompressableMimeTypes("application/json", "text/json"); // the mime types to compress
listener.getTransport().setWorkerThreadPoolConfig(threadPoolConfig);
httpServer.addListener(listener);
}
/* Add a few handlers (~= servlets) to the Grizzly server. */
/* 1. A Grizzly wrapper around the Jersey Application. */
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 HTTP handling without 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();
}
}
