下面列出了org.eclipse.jetty.server.HttpConfiguration#setSendServerVersion ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Override
public void startComponent() {
// Initialize servlet using RESTEasy and it's Guice bridge.
// The listener must be injected by the same Guice module which also binds the REST endpoints.
ServletContextHandler servletHandler = new ServletContextHandler();
servletHandler.addEventListener(listener);
servletHandler.addServlet(HttpServletDispatcher.class, "/*");
// Configure Jetty: Remove 'server' header from response and set listen port.
HttpConfiguration httpConfig = new HttpConfiguration();
httpConfig.setSendServerVersion(false);
ServerConnector connector = new ServerConnector(server, new HttpConnectionFactory(httpConfig));
connector.setPort(port);
// Starting up Jetty to serve the REST API.
server.addConnector(connector);
server.setHandler(servletHandler);
if (!LambdaUtils.tryTo(server::start, ex -> logger.error(ex, "Failed to start REST API."))) {
throw new IllegalStateException("Failed to start REST API.");
}
}
protected static void addHttpsConnector(Server server, Integer port) throws Exception {
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStorePath(Config.sslKeyStore().getAbsolutePath());
sslContextFactory.setKeyStorePassword(Config.token().getSslKeyStorePassword());
sslContextFactory.setKeyManagerPassword(Config.token().getSslKeyManagerPassword());
sslContextFactory.setTrustAll(true);
HttpConfiguration config = new HttpConfiguration();
config.setSecureScheme("https");
config.setOutputBufferSize(32768);
config.setRequestHeaderSize(8192 * 2);
config.setResponseHeaderSize(8192 * 2);
config.setSendServerVersion(true);
config.setSendDateHeader(false);
ServerConnector sslConnector = new ServerConnector(server,
new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()),
new HttpConnectionFactory(config));
sslConnector.setPort(port);
server.addConnector(sslConnector);
}
public static void main(String[] args) throws Exception
{
// jetty config
Properties properties = new Properties();
properties.load(CrudApiHandler.class.getClassLoader().getResourceAsStream("jetty.properties"));
HttpConfiguration config = new HttpConfiguration();
config.setSendServerVersion( false );
HttpConnectionFactory factory = new HttpConnectionFactory( config );
Server server = new Server();
ServerConnector connector = new ServerConnector(server,factory);
server.setConnectors( new Connector[] { connector } );
connector.setHost(properties.getProperty("host"));
connector.setPort(Integer.parseInt(properties.getProperty("port")));
server.addConnector(connector);
server.setHandler(new CrudApiHandler());
server.start();
server.join();
}
public static void main(String[] args) throws Exception
{
Server server = new Server(8080);
ServerConnector connector = server.getBean(ServerConnector.class);
HttpConfiguration config = connector.getBean(HttpConnectionFactory.class).getHttpConfiguration();
config.setSendDateHeader(true);
config.setSendServerVersion(true);
ServletContextHandler context = new ServletContextHandler(ServletContextHandler.NO_SECURITY|ServletContextHandler.NO_SESSIONS);
context.setContextPath("/");
server.setHandler(context);
context.addServlet(org.eclipse.jetty.servlet.DefaultServlet.class,"/");
context.addServlet(JsonServlet.class,"/json");
context.addServlet(PlaintextServlet.class,"/plaintext");
server.start();
server.join();
}
private Connector createConnector( final Server httpBindServer ) {
final int port = getHttpBindUnsecurePort();
if (port > 0) {
HttpConfiguration httpConfig = new HttpConfiguration();
httpConfig.setSendServerVersion( false );
configureProxiedConnector(httpConfig);
ServerConnector connector = new ServerConnector(httpBindServer, new HttpConnectionFactory(httpConfig));
// Listen on a specific network interface if it has been set.
connector.setHost(getBindInterface());
connector.setPort(port);
return connector;
}
else
{
return null;
}
}
private void configureConnectors(final Server server) throws ServerConfigurationException {
// create the http configuration
final HttpConfiguration httpConfiguration = new HttpConfiguration();
final int headerSize = DataUnit.parseDataSize(props.getWebMaxHeaderSize(), DataUnit.B).intValue();
httpConfiguration.setRequestHeaderSize(headerSize);
httpConfiguration.setResponseHeaderSize(headerSize);
httpConfiguration.setSendServerVersion(props.shouldSendServerVersion());
// Check if both HTTP and HTTPS connectors are configured and fail if both are configured
if (bothHttpAndHttpsConnectorsConfigured(props)) {
logger.error("NiFi only supports one mode of HTTP or HTTPS operation, not both simultaneously. " +
"Check the nifi.properties file and ensure that either the HTTP hostname and port or the HTTPS hostname and port are empty");
startUpFailure(new IllegalStateException("Only one of the HTTP and HTTPS connectors can be configured at one time"));
}
if (props.getSslPort() != null) {
configureHttpsConnector(server, httpConfiguration);
} else if (props.getPort() != null) {
configureHttpConnector(server, httpConfiguration);
} else {
logger.error("Neither the HTTP nor HTTPS connector was configured in nifi.properties");
startUpFailure(new IllegalStateException("Must configure HTTP or HTTPS connector"));
}
}
public DefaultConnector(Server server, int port) {
HttpConfiguration config = new HttpConfiguration();
config.setSendServerVersion(false);
config.setSendXPoweredBy(false);
HttpConnectionFactory factory = new HttpConnectionFactory(config);
this.connector = new ServerConnector(server, factory);
this.connector.setPort(port);
this.connector.setReuseAddress(true);
}
protected static void addHttpConnector(Server server, Integer port) throws Exception {
HttpConfiguration config = new HttpConfiguration();
config.setOutputBufferSize(32768);
config.setRequestHeaderSize(8192 * 2);
config.setResponseHeaderSize(8192 * 2);
config.setSendServerVersion(true);
config.setSendDateHeader(false);
ServerConnector http = new ServerConnector(server, new HttpConnectionFactory(config));
http.setIdleTimeout(30000);
http.setPort(port);
server.addConnector(http);
}
private HttpConnectionFactory newHttpConnectionFactory() {
HttpConfiguration httpConfig = new HttpConfiguration();
httpConfig.setSendDateHeader(true);
httpConfig.setSendServerVersion(false);
httpConfig.setSendXPoweredBy(false);
httpConfig.setHeaderCacheSize(connectorConfig.headerCacheSize());
httpConfig.setOutputBufferSize(connectorConfig.outputBufferSize());
httpConfig.setRequestHeaderSize(connectorConfig.requestHeaderSize());
httpConfig.setResponseHeaderSize(connectorConfig.responseHeaderSize());
if (connectorConfig.ssl().enabled() || TransportSecurityUtils.isTransportSecurityEnabled()) { // TODO Cleanup once mixed mode is gone
httpConfig.addCustomizer(new SecureRequestCustomizer());
}
return new HttpConnectionFactory(httpConfig);
}
public static void main(String[] args) throws Exception
{
Server server = new Server(8080);
ServerConnector connector = server.getBean(ServerConnector.class);
HttpConfiguration config = connector.getBean(HttpConnectionFactory.class).getHttpConfiguration();
config.setSendDateHeader(true);
config.setSendServerVersion(true);
PathHandler pathHandler = new PathHandler();
server.setHandler(pathHandler);
server.start();
server.join();
}
static void configureHttp( HttpConfiguration httpConfig, JettyConfiguration config )
{
// Date header
Boolean sendDateHeader = config.sendDateHeader().get();
if( sendDateHeader != null )
{
httpConfig.setSendDateHeader( sendDateHeader );
}
// Server version
Boolean sendServerVersion = config.sendServerVersion().get();
if( sendServerVersion != null )
{
httpConfig.setSendServerVersion( sendServerVersion );
}
// Header sizes
Integer requestHeaderSize = config.requestHeaderSize().get();
if( requestHeaderSize != null )
{
httpConfig.setRequestHeaderSize( requestHeaderSize );
}
Integer responseHeaderSize = config.responseHeaderSize().get();
if( responseHeaderSize != null )
{
httpConfig.setResponseHeaderSize( responseHeaderSize );
}
// Buffer sizes
Integer responseBufferSize = config.responseBufferSize().get();
if( responseBufferSize != null )
{
httpConfig.setOutputBufferSize( responseBufferSize );
}
}
private Connector createSSLConnector( final Server httpBindServer ) {
final int securePort = getHttpBindSecurePort();
try {
final IdentityStore identityStore = XMPPServer.getInstance().getCertificateStoreManager().getIdentityStore( ConnectionType.BOSH_C2S );
if (securePort > 0 && identityStore.getStore().aliases().hasMoreElements() ) {
if ( !identityStore.containsDomainCertificate( ) ) {
Log.warn("HTTP binding: Using certificates but they are not valid for the hosted domain");
}
final ConnectionManagerImpl connectionManager = ((ConnectionManagerImpl) XMPPServer.getInstance().getConnectionManager());
final ConnectionConfiguration configuration = connectionManager.getListener( ConnectionType.BOSH_C2S, true ).generateConnectionConfiguration();
final SslContextFactory sslContextFactory = new EncryptionArtifactFactory(configuration).getSslContextFactory();
final HttpConfiguration httpsConfig = new HttpConfiguration();
httpsConfig.setSecureScheme("https");
httpsConfig.setSecurePort(securePort);
configureProxiedConnector(httpsConfig);
httpsConfig.addCustomizer(new SecureRequestCustomizer());
httpsConfig.setSendServerVersion( false );
final ServerConnector sslConnector = new ServerConnector(httpBindServer, new SslConnectionFactory(sslContextFactory, "http/1.1"), new HttpConnectionFactory(httpsConfig));
sslConnector.setHost(getBindInterface());
sslConnector.setPort(securePort);
return sslConnector;
}
}
catch (Exception e) {
Log.error("Error creating SSL connector for Http bind", e);
}
return null;
}
AbstractConnector createConnectorJetty(SslContextFactory sslcf, String hosto, int porto, int major, int minor) {
AbstractConnector result = null;
try {
HttpConfiguration httpConfig = new HttpConfiguration();
httpConfig.setSendServerVersion(getSendServerVersion());
HttpConnectionFactory httpFactory = new HttpConnectionFactory(httpConfig);
Collection<ConnectionFactory> connectionFactories = new ArrayList<>();
result = new org.eclipse.jetty.server.ServerConnector(server);
if (tlsServerParameters != null) {
httpConfig.addCustomizer(new org.eclipse.jetty.server.SecureRequestCustomizer());
SslConnectionFactory scf = new SslConnectionFactory(sslcf, "HTTP/1.1");
connectionFactories.add(scf);
String proto = (major > 9 || (major == 9 && minor >= 3)) ? "SSL" : "SSL-HTTP/1.1";
result.setDefaultProtocol(proto);
}
connectionFactories.add(httpFactory);
result.setConnectionFactories(connectionFactories);
if (getMaxIdleTime() > 0) {
result.setIdleTimeout(Long.valueOf(getMaxIdleTime()));
}
} catch (RuntimeException rex) {
throw rex;
} catch (Exception ex) {
throw new RuntimeException(ex);
}
return result;
}
private void configureConnectors(SslContextFactory sslContextFactory) {
final HttpConfiguration httpConfiguration = new HttpConfiguration();
httpConfiguration.setSendServerVersion(false);
final HttpConnectionFactory httpConnectionFactory =
new HttpConnectionFactory(httpConfiguration);
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(this, httpConnectionFactory);
} else {
connector = new NetworkTrafficServerConnector(this, httpConnectionFactory,
sslContextFactory);
}
connector.setPort(listener.getPort());
connector.setHost(listener.getHost());
connector.setIdleTimeout(config.getLong(RestConfig.IDLE_TIMEOUT_MS_CONFIG));
connectors.add(connector);
super.addConnector(connector);
}
}
@Override
protected Connector getConnector(String host, int port) throws IOException {
org.apache.commons.configuration.Configuration config = getConfiguration();
SSLContext sslContext = getSSLContext();
if (sslContext != null) {
SSLContext.setDefault(sslContext);
}
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStorePath(config.getString(KEYSTORE_FILE_KEY,
System.getProperty(KEYSTORE_FILE_KEY, DEFAULT_KEYSTORE_FILE_LOCATION)));
sslContextFactory.setKeyStorePassword(getPassword(config, KEYSTORE_PASSWORD_KEY));
sslContextFactory.setKeyManagerPassword(getPassword(config, SERVER_CERT_PASSWORD_KEY));
sslContextFactory.setTrustStorePath(config.getString(TRUSTSTORE_FILE_KEY,
System.getProperty(TRUSTSTORE_FILE_KEY, DEFATULT_TRUSTORE_FILE_LOCATION)));
sslContextFactory.setTrustStorePassword(getPassword(config, TRUSTSTORE_PASSWORD_KEY));
sslContextFactory.setWantClientAuth(config.getBoolean(CLIENT_AUTH_KEY, Boolean.getBoolean(CLIENT_AUTH_KEY)));
List<Object> cipherList = config.getList(ATLAS_SSL_EXCLUDE_CIPHER_SUITES, DEFAULT_CIPHER_SUITES);
sslContextFactory.setExcludeCipherSuites(cipherList.toArray(new String[cipherList.size()]));
sslContextFactory.setRenegotiationAllowed(false);
String[] excludedProtocols = config.containsKey(ATLAS_SSL_EXCLUDE_PROTOCOLS) ?
config.getStringArray(ATLAS_SSL_EXCLUDE_PROTOCOLS) : DEFAULT_EXCLUDE_PROTOCOLS;
if (excludedProtocols != null && excludedProtocols.length > 0) {
sslContextFactory.addExcludeProtocols(excludedProtocols);
}
// SSL HTTP Configuration
// HTTP Configuration
HttpConfiguration http_config = new HttpConfiguration();
http_config.setSecureScheme("https");
final int bufferSize = AtlasConfiguration.WEBSERVER_REQUEST_BUFFER_SIZE.getInt();
http_config.setSecurePort(port);
http_config.setRequestHeaderSize(bufferSize);
http_config.setResponseHeaderSize(bufferSize);
http_config.setSendServerVersion(true);
http_config.setSendDateHeader(false);
HttpConfiguration https_config = new HttpConfiguration(http_config);
https_config.addCustomizer(new SecureRequestCustomizer());
// SSL Connector
ServerConnector sslConnector = new ServerConnector(server,
new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()),
new HttpConnectionFactory(https_config));
sslConnector.setPort(port);
server.addConnector(sslConnector);
return sslConnector;
}
protected Connector getConnector(int port) throws IOException {
org.apache.commons.configuration.Configuration config = getConfiguration();
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStorePath(config.getString(KEYSTORE_FILE_KEY,
System.getProperty(KEYSTORE_FILE_KEY, DEFAULT_KEYSTORE_FILE_LOCATION)));
sslContextFactory.setKeyStorePassword(getPassword(config, KEYSTORE_PASSWORD_KEY));
sslContextFactory.setKeyManagerPassword(getPassword(config, SERVER_CERT_PASSWORD_KEY));
sslContextFactory.setTrustStorePath(config.getString(TRUSTSTORE_FILE_KEY,
System.getProperty(TRUSTSTORE_FILE_KEY, DEFATULT_TRUSTORE_FILE_LOCATION)));
sslContextFactory.setTrustStorePassword(getPassword(config, TRUSTSTORE_PASSWORD_KEY));
sslContextFactory.setWantClientAuth(config.getBoolean(CLIENT_AUTH_KEY, Boolean.getBoolean(CLIENT_AUTH_KEY)));
List<Object> cipherList = config.getList(ATLAS_SSL_EXCLUDE_CIPHER_SUITES, DEFAULT_CIPHER_SUITES);
sslContextFactory.setExcludeCipherSuites(cipherList.toArray(new String[cipherList.size()]));
sslContextFactory.setRenegotiationAllowed(false);
String[] excludedProtocols = config.containsKey(ATLAS_SSL_EXCLUDE_PROTOCOLS) ?
config.getStringArray(ATLAS_SSL_EXCLUDE_PROTOCOLS) : DEFAULT_EXCLUDE_PROTOCOLS;
if (excludedProtocols != null && excludedProtocols.length > 0) {
sslContextFactory.addExcludeProtocols(excludedProtocols);
}
// SSL HTTP Configuration
// HTTP Configuration
HttpConfiguration http_config = new HttpConfiguration();
http_config.setSecureScheme("https");
final int bufferSize = AtlasConfiguration.WEBSERVER_REQUEST_BUFFER_SIZE.getInt();
http_config.setSecurePort(port);
http_config.setRequestHeaderSize(bufferSize);
http_config.setResponseHeaderSize(bufferSize);
http_config.setSendServerVersion(true);
http_config.setSendDateHeader(false);
HttpConfiguration https_config = new HttpConfiguration(http_config);
https_config.addCustomizer(new SecureRequestCustomizer());
// SSL Connector
ServerConnector sslConnector = new ServerConnector(server,
new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()),
new HttpConnectionFactory(https_config));
sslConnector.setPort(port);
server.addConnector(sslConnector);
return sslConnector;
}
public static void main(String[] args) throws Exception {
int timeout = (int) Duration.ONE_HOUR.getMilliseconds();
System.setProperty(WICKET_CFG, CfgType.development.toString());
Server server = new Server();
ServerConnector connector = new ServerConnector(server);
// Set some timeout options to make debugging easier.
connector.setIdleTimeout(timeout);
connector.setSoLingerTime(-1);
connector.setPort(8080);
server.addConnector(connector);
Resource keystore = Resource.newClassPathResource("/keystore");
if (keystore != null && keystore.exists()) {
// if a keystore for a SSL certificate is available, start a SSL
// connector on port 8443.
// By default, the quickstart comes with a Apache Wicket Quickstart
// Certificate that expires about half way september 2021. Do not
// use this certificate anywhere important as the passwords are
// available in the source.
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStoreResource(keystore);
sslContextFactory.setKeyStorePassword("wicket");
sslContextFactory.setTrustStoreResource(keystore);
sslContextFactory.setKeyManagerPassword("wicket");
// HTTP Configuration
HttpConfiguration httpConfig = new HttpConfiguration();
httpConfig.setSecureScheme("https");
httpConfig.setSecurePort(8443);
httpConfig.setOutputBufferSize(32768);
httpConfig.setRequestHeaderSize(8192);
httpConfig.setResponseHeaderSize(8192);
httpConfig.setSendServerVersion(true);
httpConfig.setSendDateHeader(false);
// SSL HTTP Configuration
HttpConfiguration httpsConfig = new HttpConfiguration(httpConfig);
httpsConfig.addCustomizer(new SecureRequestCustomizer());
// SSL Connector
ServerConnector sslConnector = new ServerConnector(server,
new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()),
new HttpConnectionFactory(httpsConfig));
sslConnector.setPort(8443);
server.addConnector(sslConnector);
System.out.println("SSL access to the quickstart has been enabled on port 8443");
System.out.println("You can access the application using SSL on https://localhost:8443");
System.out.println();
}
WebAppContext bb = new WebAppContext();
bb.setServer(server);
bb.setContextPath("/");
bb.setWar("src/main/webapp");
// START JMX SERVER
// MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
// MBeanContainer mBeanContainer = new MBeanContainer(mBeanServer);
// server.getContainer().addEventListener(mBeanContainer);
// mBeanContainer.start();
server.setHandler(bb);
try {
System.out.println(">>> STARTING EMBEDDED JETTY SERVER, PRESS ANY KEY TO STOP");
server.start();
System.in.read();
System.out.println(">>> STOPPING EMBEDDED JETTY SERVER");
server.stop();
server.join();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
/**
* Inits the.
*
* @throws Exception the exception
*/
public final void init() throws Exception {
initialised = true;
server = new Server();
Security.addProvider(new BouncyCastleProvider());
// Setup JMX
final MBeanContainer mbContainer = new MBeanContainer(ManagementFactory.getPlatformMBeanServer());
server.addBean(mbContainer);
final org.eclipse.jetty.webapp.Configurations classlist = org.eclipse.jetty.webapp.Configurations.setServerDefault(server);
final HttpConfiguration http_config = new HttpConfiguration();
http_config.setSecureScheme("https");
http_config.setSecurePort(28443);
http_config.setSendServerVersion(false);
final HttpConfiguration https_config = new HttpConfiguration(http_config);
https_config.addCustomizer(new SecureRequestCustomizer());
final SslContextFactory.Server sslContextFactory = new SslContextFactory.Server();
sslContextFactory.setKeyStoreType("PKCS12");
sslContextFactory.setKeyStorePath("target/keystore.p12");
sslContextFactory.setTrustStorePath("target/keystore.p12");
sslContextFactory.setTrustStoreType("PKCS12");
sslContextFactory.setKeyStorePassword("changeit");
sslContextFactory.setTrustStorePassword("changeit");
sslContextFactory.setKeyManagerPassword("changeit");
sslContextFactory.setCertAlias("jetty");
sslContextFactory.setIncludeCipherSuites("TLS_AES_256_GCM_SHA384", "TLS_CHACHA20_POLY1305_SHA256",
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384", "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256",
"TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256");
sslContextFactory.setExcludeProtocols("SSL", "SSLv2", "SSLv2Hello", "SSLv3", "TLSv1", "TLSv1.1");
sslContextFactory.setIncludeProtocols("TLSv1.2", "TLSv1.3");
final ServerConnector sslConnector = new ServerConnector(server,
new SslConnectionFactory(sslContextFactory, "http/1.1"), new HttpConnectionFactory(https_config),
new HTTP2CServerConnectionFactory(https_config));
sslConnector.setPort(PORT);
server.setConnectors(new ServerConnector[] { sslConnector });
final WebAppContext handler = new WebAppContext("src/main/webapp", "/");
handler.setExtraClasspath("target/classes");
handler.setParentLoaderPriority(true);
handler.setConfigurationDiscovered(true);
handler.setClassLoader(Thread.currentThread().getContextClassLoader());
final HandlerList handlers = new HandlerList();
handlers.setHandlers(new Handler[] { handler, new DefaultHandler() });
server.setHandler(handlers);
}
private HttpConfiguration createHttpConfiguration() {
HttpConfiguration httpConfiguration = new HttpConfiguration();
httpConfiguration.setSendServerVersion(true);
httpConfiguration.setSendDateHeader(true);
return httpConfiguration;
}
/**
* Create and start server.
*
* @throws Exception
* when server cannot be started.
*/
public static void start() throws Exception {
MetricRegistry registry = new MetricRegistry();
QueuedThreadPool threadPool = new InstrumentedQueuedThreadPool(registry);
threadPool.setName("esigate");
threadPool.setMaxThreads(maxThreads);
threadPool.setMinThreads(minThreads);
srv = new Server(threadPool);
srv.setStopAtShutdown(true);
srv.setStopTimeout(5000);
// HTTP Configuration
HttpConfiguration httpConfig = new HttpConfiguration();
httpConfig.setOutputBufferSize(outputBufferSize);
httpConfig.setSendServerVersion(false);
Timer processTime = registry.timer("processTime");
try (ServerConnector connector =
new InstrumentedServerConnector("main", EsigateServer.port, srv, registry,
new InstrumentedConnectionFactory(new HttpConnectionFactory(httpConfig), processTime));
ServerConnector controlConnector = new ServerConnector(srv)) {
// Main connector
connector.setIdleTimeout(EsigateServer.idleTimeout);
connector.setSoLingerTime(-1);
connector.setName("main");
connector.setAcceptQueueSize(200);
// Control connector
controlConnector.setHost("127.0.0.1");
controlConnector.setPort(EsigateServer.controlPort);
controlConnector.setName("control");
srv.setConnectors(new Connector[] {connector, controlConnector});
// War
ProtectionDomain protectionDomain = EsigateServer.class.getProtectionDomain();
String warFile = protectionDomain.getCodeSource().getLocation().toExternalForm();
String currentDir = new File(protectionDomain.getCodeSource().getLocation().getPath()).getParent();
File workDir = resetTempDirectory(currentDir);
WebAppContext context = new WebAppContext(warFile, EsigateServer.contextPath);
context.setServer(srv);
context.setTempDirectory(workDir);
if (StringUtils.isNoneEmpty(sessionCookieName)) {
context.getSessionHandler().getSessionCookieConfig().setName(sessionCookieName);
}
// Add extra classpath (allows to add extensions).
if (EsigateServer.extraClasspath != null) {
context.setExtraClasspath(EsigateServer.extraClasspath);
}
// Add the handlers
HandlerCollection handlers = new HandlerList();
// control handler must be the first one.
// Work in progress, currently disabled.
handlers.addHandler(new ControlHandler(registry));
InstrumentedHandler ih = new InstrumentedHandler(registry);
ih.setName("main");
ih.setHandler(context);
handlers.addHandler(ih);
srv.setHandler(handlers);
srv.start();
srv.join();
}
}