private void loadListeners() { for (ListenerInfo li : listeners) { webServer.addConnector(li.listener); } }
private void loadListeners() { for (Connector c : listeners) { webServer.addConnector(c); } }
public void addConnector(Connector connector) { server.addConnector(connector); }
/** * Creates the http connection */ private void createConnector() { final ServerConnector http = new ServerConnector(jetty); http.setPort(0); // Severely taxed environments may have significant delays when executing. http.setIdleTimeout(30000L); jetty.addConnector(http); }
private RoutingHandler buildRoutingHandler(MetricRegistry metricRegistry, Server server, Handler applicationHandler, Handler adminHandler) { final List<Connector> appConnectors = buildAppConnectors(metricRegistry, server); final List<Connector> adConnectors = buildAdminConnectors(metricRegistry, server); final Map<Connector, Handler> handlers = new LinkedHashMap<>(); for (Connector connector : appConnectors) { server.addConnector(connector); handlers.put(connector, applicationHandler); } for (Connector connector : adConnectors) { server.addConnector(connector); handlers.put(connector, adminHandler); } return new RoutingHandler(handlers); }
public static ServerConnector addHttpConnector(Server server) { ServerConnector connector = new ServerConnector(server); server.addConnector(connector); return connector; }
public JettyAdminServer(String address, int port, int timeout, String commandUrl) { this.port = port; this.idleTimeout = timeout; this.commandUrl = commandUrl; this.address = address; server = new Server(); ServerConnector connector = new ServerConnector(server); connector.setHost(address); connector.setPort(port); connector.setIdleTimeout(idleTimeout); server.addConnector(connector); ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS); context.setContextPath("/*"); server.setHandler(context); context.addServlet(new ServletHolder(new CommandServlet()), commandUrl + "/*"); }
public TestJettyWebSocketServer(final WebSocketHandler webSocketHandler) { this.server = new Server(); ServerConnector connector = new ServerConnector(this.server); connector.setPort(0); this.server.addConnector(connector); this.server.setHandler(new org.eclipse.jetty.websocket.server.WebSocketHandler() { @Override public void configure(WebSocketServletFactory factory) { factory.setCreator(new WebSocketCreator() { @Override public Object createWebSocket(ServletUpgradeRequest req, ServletUpgradeResponse resp) { if (!CollectionUtils.isEmpty(req.getSubProtocols())) { resp.setAcceptedSubProtocol(req.getSubProtocols().get(0)); } JettyWebSocketSession session = new JettyWebSocketSession(null, null); return new JettyWebSocketHandlerAdapter(webSocketHandler, session); } }); } }); }
private void buildConnector(Config config) throws Exception { final ServerConnector serverConnector; if (config.getBoolean(DrillOnYarnConfig.HTTP_ENABLE_SSL)) { serverConnector = createHttpsConnector(config); } else { serverConnector = createHttpConnector(config); } jettyServer.addConnector(serverConnector); }
/** Constructs a server to run with the given ConnectionFactory on the given address/port. */ public HttpServer(ResponderServlet servlet, ConnectionFactory connectionFactory, String bindAddress, int port) throws IOException { this.server = new org.eclipse.jetty.server.Server(); HttpConfiguration httpConfig = new HttpConfiguration(); HttpConnectionFactory httpFactory = new HttpConnectionFactory(httpConfig); ServerConnector connector = new ServerConnector(this.server, connectionFactory, httpFactory); if (bindAddress != null) { connector.setHost(bindAddress); } connector.setPort(port); server.addConnector(connector); ServletHandler handler = new ServletHandler(); server.setHandler(handler); handler.addServletWithMapping(new ServletHolder(servlet), "/*"); }
/** * Construct a Jetty Server instance. */ public static Server jettyCreateServer(Integer port, String host, Integer httpsPort, Integer headerBufferSize, Boolean disableHttpBinding) { Server server = new Server(); if (httpsPort == null || httpsPort <= 0 || disableHttpBinding == null || disableHttpBinding == false) { HttpConfiguration httpConfig = new HttpConfiguration(); httpConfig.setSendDateHeader(true); if (null != headerBufferSize) { httpConfig.setRequestHeaderSize(headerBufferSize); } ServerConnector httpConnector = new ServerConnector( server, new HttpConnectionFactory(httpConfig) ); httpConnector.setPort(ObjectReader.getInt(port, 80)); httpConnector.setIdleTimeout(200000); httpConnector.setHost(host); server.addConnector(httpConnector); } return server; }
private static Server createServer(Handler handler, int port, KeyStore keyStore, String keyPassword) throws Exception { Server server = new Server(); SslContextFactory sslContextFactory = new SslContextFactory(); sslContextFactory.setIncludeProtocols("TLSv1.2"); sslContextFactory.setKeyStore(keyStore); sslContextFactory.setKeyManagerPassword(keyPassword); HttpConfiguration httpsConfig = new HttpConfiguration(); httpsConfig.addCustomizer(new SecureRequestCustomizer()); ServerConnector sslConnector = new ServerConnector(server, new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()), new HttpConnectionFactory(httpsConfig)); sslConnector.setPort(port); server.addConnector(sslConnector); server.setHandler(handler); return server; }
@Override protected void initServer() throws Exception { this.jettyServer = new Server(); ServletHttpHandlerAdapter servlet = createServletAdapter(); ServletHolder servletHolder = new ServletHolder(servlet); servletHolder.setAsyncSupported(true); this.contextHandler = new ServletContextHandler(this.jettyServer, "", false, false); this.contextHandler.addServlet(servletHolder, "/"); this.contextHandler.start(); ServerConnector connector = new ServerConnector(this.jettyServer); connector.setHost(getHost()); connector.setPort(getPort()); this.jettyServer.addConnector(connector); }
@Test public void shouldAddHttpSocketConnector() throws Exception { ArgumentCaptor<Connector> captor = ArgumentCaptor.forClass(Connector.class); jetty9Server.configure(); verify(server, times(2)).addConnector(captor.capture()); List<Connector> connectors = captor.getAllValues(); Connector plainConnector = connectors.get(0); assertThat(plainConnector instanceof ServerConnector, is(true)); ServerConnector connector = (ServerConnector) plainConnector; assertThat(connector.getServer(), is(server)); assertThat(connector.getConnectionFactories().size(), is(1)); ConnectionFactory connectionFactory = connector.getConnectionFactories().iterator().next(); assertThat(connectionFactory instanceof HttpConnectionFactory, is(true)); }
public static ServerConnector addHttpsConnector(Server server) throws IOException, URISyntaxException { String keyStoreFile = resourceAsFile("ssltest-keystore.jks").getAbsolutePath(); SslContextFactory sslContextFactory = new SslContextFactory(keyStoreFile); sslContextFactory.setKeyStorePassword("changeit"); String trustStoreFile = resourceAsFile("ssltest-cacerts.jks").getAbsolutePath(); sslContextFactory.setTrustStorePath(trustStoreFile); sslContextFactory.setTrustStorePassword("changeit"); HttpConfiguration httpsConfig = new HttpConfiguration(); httpsConfig.setSecureScheme("https"); httpsConfig.addCustomizer(new SecureRequestCustomizer()); ServerConnector connector = new ServerConnector(server, new SslConnectionFactory(sslContextFactory, "http/1.1"), new HttpConnectionFactory(httpsConfig)); server.addConnector(connector); return connector; }
@Test public void shouldAddSSLSocketConnector() throws Exception { ArgumentCaptor<Connector> captor = ArgumentCaptor.forClass(Connector.class); jetty9Server.configure(); verify(server, times(2)).addConnector(captor.capture()); List<Connector> connectors = captor.getAllValues(); Connector sslConnector = connectors.get(1); assertThat(sslConnector instanceof ServerConnector, is(true)); ServerConnector connector = (ServerConnector) sslConnector; assertThat(connector.getServer(), is(server)); assertThat(connector.getConnectionFactories().size(), is(2)); Iterator<ConnectionFactory> iterator = connector.getConnectionFactories().iterator(); ConnectionFactory first = iterator.next(); ConnectionFactory second = iterator.next(); assertThat(first instanceof SslConnectionFactory, is(true)); SslConnectionFactory sslConnectionFactory = (SslConnectionFactory) first; assertThat(sslConnectionFactory.getProtocol(), is("SSL")); assertThat(sslConnectionFactory.getNextProtocol(), is("HTTP/1.1")); assertThat(second instanceof HttpConnectionFactory, is(true)); }
server.addConnector(connector);
server.addConnector(connector);
@Override public void configure() throws Exception { server.addEventListener(mbeans()); server.addConnector(plainConnector()); server.addConnector(sslConnector()); ContextHandlerCollection handlers = new ContextHandlerCollection(); deploymentManager.setContexts(handlers); createWebAppContext(); JettyCustomErrorPageHandler errorHandler = new JettyCustomErrorPageHandler(); webAppContext.setErrorHandler(errorHandler); webAppContext.setGzipHandler(gzipHandler()); server.addBean(errorHandler); server.addBean(deploymentManager); HandlerCollection serverLevelHandlers = new HandlerCollection(); serverLevelHandlers.setHandlers(new Handler[]{handlers}); server.setHandler(serverLevelHandlers); performCustomConfiguration(); server.setStopAtShutdown(true); }
null); server.addConnector(conn);