private static void serve(HttpServlet servlet) throws Exception { ServletHandler handler = new ServletHandler(); handler.addServletWithMapping(new ServletHolder(servlet), "/"); HttpConfiguration httpConfig = new HttpConfiguration(); httpConfig.setOutputBufferSize(32 * 1024); httpConfig.setRequestHeaderSize(8 * 1024); httpConfig.setResponseHeaderSize(8 * 1024); httpConfig.setSendDateHeader(true); HttpConnectionFactory connFac = new HttpConnectionFactory(httpConfig); Server server = new Server(3000); ServerConnector connector = new ServerConnector( server, Executors.newFixedThreadPool(4), new ScheduledExecutorScheduler(), new MappedByteBufferPool(), 1, 4, connFac); connector.setAcceptQueueSize(1000); connector.setReuseAddress(true); server.setHandler(handler); server.start(); }
protected final void doConfigure(final HttpConnectionFactory factory) { factory.getHttpConfiguration().addCustomizer(new ForwardedRequestCustomizer()); final HttpConfiguration config = factory.getHttpConfiguration(); // HTTP/1.1 requires Date header if possible config.setSendDateHeader(true); config.setSendServerVersion(this.config.sendServerHeader()); config.setSendXPoweredBy(this.config.sendServerHeader()); }
public void startServletContainer(Configuration conf) throws Exception { if (server != null) { LOG.error("ServletContainer already running"); return; } // Inject the conf for the test by being first to make singleton RESTServlet.getInstance(conf, UserProvider.instantiate(conf)); // set up the Jersey servlet container for Jetty ResourceConfig app = new ResourceConfig() .packages("org.apache.hadoop.hbase.rest") .register(Jackson1Feature.class); ServletHolder sh = new ServletHolder(new ServletContainer(app)); // set up Jetty and run the embedded server server = new Server(0); LOG.info("configured " + ServletContainer.class.getName()); HttpConfiguration httpConfig = new HttpConfiguration(); httpConfig.setSendDateHeader(false); httpConfig.setSendServerVersion(false); ServerConnector serverConnector = new ServerConnector(server, new HttpConnectionFactory(httpConfig)); serverConnector.setPort(testServletPort); server.addConnector(serverConnector); // set up context ServletContextHandler ctxHandler = new ServletContextHandler(server, "/", ServletContextHandler.SESSIONS); ctxHandler.addServlet(sh, "/*"); // Load filters specified from configuration. String[] filterClasses = conf.getStrings(Constants.FILTER_CLASSES, ArrayUtils.EMPTY_STRING_ARRAY); for (String filter : filterClasses) { filter = filter.trim(); ctxHandler.addFilter(filter, "/*", EnumSet.of(DispatcherType.REQUEST)); } LOG.info("Loaded filter classes :" + filterClasses); conf.set(RESTServer.REST_CSRF_BROWSER_USERAGENTS_REGEX_KEY, ".*"); RESTServer.addCSRFFilter(ctxHandler, conf); HttpServerUtil.constrainHttpMethods(ctxHandler); // start the server server.start(); // get the port testServletPort = ((ServerConnector) server.getConnectors()[0]).getLocalPort(); LOG.info("started " + server.getClass().getName() + " on port " + testServletPort); }
private void prepareProxy(Map<String, String> initParams) throws Exception { proxy = new Server(); HttpConfiguration configuration = new HttpConfiguration(); configuration.setSendDateHeader(false); configuration.setSendServerVersion(false); String value = initParams.get("outputBufferSize"); if (value != null) configuration.setOutputBufferSize(Integer.valueOf(value)); proxyConnector = new ServerConnector(proxy, new HttpConnectionFactory(configuration)); proxy.addConnector(proxyConnector); proxyContext = new ServletContextHandler(proxy, "/", true, false); ServletHolder proxyServletHolder = new ServletHolder(proxyServlet); proxyServletHolder.setInitParameters(initParams); proxyContext.addServlet(proxyServletHolder, "/*"); proxy.start(); client = prepareClient(); }
/** * Loads jetty configuration from the given URL. * * @param cfgUrl URL to load configuration from. * @throws GridException if load failed. */ private void loadJettyConfiguration(@Nullable URL cfgUrl) throws GridException { if (cfgUrl == null) { HttpConfiguration httpCfg = new HttpConfiguration(); httpCfg.setSecureScheme("https"); httpCfg.setSecurePort(8443); httpCfg.setSendServerVersion(true); httpCfg.setSendDateHeader(true); String srvPortStr = System.getProperty(GG_JETTY_PORT, "8080"); int srvPort; try { srvPort = Integer.valueOf(srvPortStr); } catch (NumberFormatException ignore) { throw new GridException( "Failed to start Jetty server because GRIDGAIN_JETTY_PORT system property " + "cannot be cast to integer: " + srvPortStr); } httpSrv = new Server(new QueuedThreadPool(20, 200)); ServerConnector srvConn = new ServerConnector(httpSrv, new HttpConnectionFactory(httpCfg)); srvConn.setHost(System.getProperty(GG_JETTY_HOST, "localhost")); srvConn.setPort(srvPort); srvConn.setIdleTimeout(30000L); srvConn.setReuseAddress(true); httpSrv.addConnector(srvConn); httpSrv.setStopAtShutdown(false); } else { XmlConfiguration cfg; try { cfg = new XmlConfiguration(cfgUrl); } catch (FileNotFoundException e) { throw new GridSpiException("Failed to find configuration file: " + cfgUrl, e); } catch (SAXException e) { throw new GridSpiException("Failed to parse configuration file: " + cfgUrl, e); } catch (IOException e) { throw new GridSpiException("Failed to load configuration file: " + cfgUrl, e); } catch (Exception e) { throw new GridSpiException( "Failed to start HTTP server with configuration file: " + cfgUrl, e); } try { httpSrv = (Server) cfg.configure(); } catch (Exception e) { throw new GridException("Failed to start Jetty HTTP server.", e); } } assert httpSrv != null; httpSrv.setHandler(jettyHnd); override(getJettyConnector()); }
@Override public void run() { try { // Set GAE SystemProperties setSystemProperties(); // Create the server, connector and associated instances QueuedThreadPool threadpool = new QueuedThreadPool(); server = new Server(threadpool); HttpConfiguration httpConfig = new HttpConfiguration(); ServerConnector connector = new ServerConnector(server, new HttpConnectionFactory(httpConfig)); connector.setPort(port); server.addConnector(connector); MappedByteBufferPool bufferpool = new MappedByteBufferPool(); // Basic jetty.xml handler setup HandlerCollection handlers = new HandlerCollection(); ContextHandlerCollection contexts = new ContextHandlerCollection(); // TODO is a context handler collection needed for a // single context? handlers.setHandlers(new Handler[] {contexts, new DefaultHandler()}); server.setHandler(handlers); // Configuration as done by gae.mod/gae.ini httpConfig.setOutputAggregationSize(32768); threadpool.setMinThreads(10); threadpool.setMaxThreads(500); threadpool.setIdleTimeout(60000); httpConfig.setOutputBufferSize(32768); httpConfig.setRequestHeaderSize(8192); httpConfig.setResponseHeaderSize(8192); httpConfig.setSendServerVersion(true); httpConfig.setSendDateHeader(false); httpConfig.setDelayDispatchUntilContent(false); // Setup Server as done by gae.xml server.addBean(bufferpool); httpConfig.setHeaderCacheSize(512); RequestLogHandler requestLogHandler = new RequestLogHandler(); handlers.addHandler(requestLogHandler); File logs = File.createTempFile("logs", "logs"); logs.delete(); logs.mkdirs(); NCSARequestLog requestLog = new NCSARequestLog(logs.getCanonicalPath() + "/request.yyyy_mm_dd.log"); requestLogHandler.setRequestLog(requestLog); requestLog.setRetainDays(2); requestLog.setAppend(true); requestLog.setExtended(true); requestLog.setLogTimeZone("GMT"); requestLog.setLogLatency(true); requestLog.setPreferProxiedForAddress(true); // Ugly hack to delete possible previous run lock file new File("target/log.0.lck").delete(); new File("target/log.0.1.lck").delete(); // configuration from root.xml VmRuntimeWebAppContext context = new VmRuntimeWebAppContext(); context.setContextPath("/"); // find the sibling testwebapp target File currentDir = new File("").getAbsoluteFile(); File webAppLocation = new File(currentDir, "target/webapps/testwebapp"); context.setResourceBase(webAppLocation.getAbsolutePath()); context.init("WEB-INF/appengine-web.xml"); context.setParentLoaderPriority(true); // true in tests for easier mocking // Hack to find the webdefault.xml File webDefault = new File(currentDir.getParentFile(), "docker/etc/webdefault.xml"); context.setDefaultsDescriptor(webDefault.getAbsolutePath()); contexts.addHandler(context); // start and join server.start(); } catch (Exception e) { e.printStackTrace(); } finally { started.countDown(); } try { if (Log.getLogger(Server.class).isDebugEnabled()) server.dumpStdErr(); server.join(); } catch (Exception e) { e.printStackTrace(); } }
protected AbstractConnector createConnectorJettyInternal( Server server, JettyHttpEndpoint endpoint, SslContextFactory sslcf) { try { String hosto = endpoint.getHttpUri().getHost(); int porto = endpoint.getPort(); org.eclipse.jetty.server.HttpConfiguration httpConfig = new org.eclipse.jetty.server.HttpConfiguration(); httpConfig.setSendServerVersion(endpoint.isSendServerVersion()); httpConfig.setSendDateHeader(endpoint.isSendDateHeader()); httpConfig.setSendDateHeader(endpoint.isSendDateHeader()); if (requestBufferSize != null) { // Does not work // httpConfig.setRequestBufferSize(requestBufferSize); } if (requestHeaderSize != null) { httpConfig.setRequestHeaderSize(requestHeaderSize); } if (responseBufferSize != null) { httpConfig.setOutputBufferSize(responseBufferSize); } if (responseHeaderSize != null) { httpConfig.setResponseHeaderSize(responseHeaderSize); } if (useXForwardedForHeader) { httpConfig.addCustomizer(new ForwardedRequestCustomizer()); } HttpConnectionFactory httpFactory = new org.eclipse.jetty.server.HttpConnectionFactory(httpConfig); ArrayList<ConnectionFactory> connectionFactories = new ArrayList<ConnectionFactory>(); ServerConnector result = new org.eclipse.jetty.server.ServerConnector(server); if (sslcf != null) { httpConfig.addCustomizer(new org.eclipse.jetty.server.SecureRequestCustomizer()); SslConnectionFactory scf = new org.eclipse.jetty.server.SslConnectionFactory(sslcf, "HTTP/1.1"); connectionFactories.add(scf); // The protocol name can be "SSL" or "SSL-HTTP/1.1" depending on the version of Jetty result.setDefaultProtocol(scf.getProtocol()); } connectionFactories.add(httpFactory); result.setConnectionFactories(connectionFactories); result.setPort(porto); if (hosto != null) { result.setHost(hosto); } /* if (getSocketConnectorProperties() != null && !"https".equals(endpoint.getProtocol())) { // must copy the map otherwise it will be deleted Map<String, Object> properties = new HashMap<String, Object>(getSocketConnectorProperties()); IntrospectionSupport.setProperties(httpConfig, properties); if (properties.size() > 0) { throw new IllegalArgumentException("There are " + properties.size() + " parameters that couldn't be set on the SocketConnector." + " Check the uri if the parameters are spelt correctly and that they are properties of the SelectChannelConnector." + " Unknown parameters=[" + properties + "]"); } } else*/ if (getSslSocketConnectorProperties() != null && "https".equals(endpoint.getProtocol())) { // must copy the map otherwise it will be deleted Map<String, Object> properties = new HashMap<String, Object>(getSslSocketConnectorProperties()); IntrospectionSupport.setProperties(sslcf, properties); if (properties.size() > 0) { throw new IllegalArgumentException( "There are " + properties.size() + " parameters that couldn't be set on the SocketConnector." + " Check the uri if the parameters are spelt correctly and that they are properties of the SelectChannelConnector." + " Unknown parameters=[" + properties + "]"); } } return result; } catch (Exception e) { throw ObjectHelper.wrapRuntimeCamelException(e); } }
public void start() throws Exception { // Configure Server server = new Server(); if (ssl) { // HTTP Configuration HttpConfiguration http_config = new HttpConfiguration(); http_config.setSecureScheme("https"); http_config.setSecurePort(0); http_config.setOutputBufferSize(32768); http_config.setRequestHeaderSize(8192); http_config.setResponseHeaderSize(8192); http_config.setSendServerVersion(true); http_config.setSendDateHeader(false); sslContextFactory = new SslContextFactory(); sslContextFactory.setKeyStorePath( MavenTestingUtils.getTestResourceFile("keystore").getAbsolutePath()); sslContextFactory.setKeyStorePassword("storepwd"); sslContextFactory.setKeyManagerPassword("keypwd"); 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 connector = new ServerConnector( server, new SslConnectionFactory(sslContextFactory, "http/1.1"), new HttpConnectionFactory(https_config)); connector.setPort(0); } else { // Basic HTTP connector connector = new ServerConnector(server); connector.setPort(0); } server.addConnector(connector); ServletContextHandler context = new ServletContextHandler(); context.setContextPath("/"); server.setHandler(context); // Serve capture servlet context.addServlet(new ServletHolder(servlet), "/*"); // Start Server server.start(); // Establish the Server URI String host = connector.getHost(); if (host == null) { host = "localhost"; } int port = connector.getLocalPort(); serverUri = new URI(String.format("%s://%s:%d/", ssl ? "wss" : "ws", host, port)); // Some debugging if (LOG.isDebugEnabled()) { LOG.debug(server.dump()); } }