private static ServerConnector createConnector(Server s, int port){ ServerConnector connector = new ServerConnector(s); connector.setHost("0.0.0.0"); connector.setPort(port); return connector; }
private static void initializeConnector(ServerConnector connector, String host, int port) { // Set some timeout options to make debugging easier. connector.setIdleTimeout(TimeUnit.HOURS.toMillis(1)); connector.setSoLingerTime(-1); connector.setHost(host); connector.setPort(port); }
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 + "/*"); }
/** 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 Connector createConnector( final Server httpBindServer ) { final int port = getHttpBindUnsecurePort(); if (port > 0) { HttpConfiguration httpConfig = new HttpConfiguration(); 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 AbstractConnector createConnector(InetSocketAddress address, Server server) { ServerConnector connector = new ServerConnector(server, this.acceptors, this.selectors); connector.setHost(address.getHostString()); connector.setPort(address.getPort()); for (ConnectionFactory connectionFactory : connector.getConnectionFactories()) { if (connectionFactory instanceof HttpConfiguration.ConnectionFactory) { ((HttpConfiguration.ConnectionFactory) connectionFactory) .getHttpConfiguration().setSendServerVersion(false); } } return connector; }
/** * Starts jetty server. * * @param handler Handler. * @param props Cluster properties. * @throws Exception If failed. */ public void start(Handler handler, ClusterProperties props) throws Exception { if (server == null) { server = new Server(); ServerConnector connector = new ServerConnector(server); connector.setHost(props.httpServerHost()); connector.setPort(props.httpServerPort()); connector.setIdleTimeout(props.idleTimeout()); server.addConnector(connector); server.setHandler(handler); server.start(); } else throw new IllegalStateException("Jetty server has already been started."); }
/** * Create a channel connector for "http/https" requests */ Connector createChannelConnector(int queueSize, Builder b) { ServerConnector connector; final HttpConfiguration conf = new HttpConfiguration(); conf.setRequestHeaderSize(1024*64); final HttpConnectionFactory http = new HttpConnectionFactory(conf); if (!b.useSSL) { connector = new ServerConnector(webServer, http); } else { SslContextFactory sslContextFactory = new SslContextFactory(); sslContextFactory.setKeyStorePath(b.keyStorePath); Set<String> excludedSSLProtocols = Sets.newHashSet( Splitter.on(",").trimResults().omitEmptyStrings().split( Strings.nullToEmpty(b.conf.getVar(ConfVars.HIVE_SSL_PROTOCOL_BLACKLIST)))); sslContextFactory.addExcludeProtocols(excludedSSLProtocols.toArray( new String[excludedSSLProtocols.size()])); sslContextFactory.setKeyStorePassword(b.keyStorePassword); connector = new ServerConnector(webServer, sslContextFactory, http); } connector.setAcceptQueueSize(queueSize); connector.setReuseAddress(true); connector.setHost(b.host); connector.setPort(b.port); return connector; }
/** Constructs a server to run on the named port on the specified address. */ public HttpServer(ResponderServlet servlet, String bindAddress, int port) throws IOException { this.server = new org.eclipse.jetty.server.Server(); ServerConnector connector = new ServerConnector(this.server); connector.setAcceptQueueSize(128); connector.setIdleTimeout(10000); if (bindAddress != null) { connector.setHost(bindAddress); } connector.setPort(port); server.addConnector(connector); ServletHandler handler = new ServletHandler(); handler.addServletWithMapping(new ServletHolder(servlet), "/*"); ServletContextHandler sch = new ServletContextHandler(); sch.setServletHandler(handler); server.setHandler(sch); }
@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); }
private ServerConnector createConnector(Server server, SslContextFactory sslContextFactory, InetSocketAddress address) { HttpConfiguration config = new HttpConfiguration(); config.setSendServerVersion(false); config.setSecureScheme("https"); config.setSecurePort(address.getPort()); config.addCustomizer(new SecureRequestCustomizer()); ServerConnector connector = createServerConnector(server, sslContextFactory, config); connector.setPort(address.getPort()); connector.setHost(address.getHostString()); return connector; }
mServerConnector.setHost(mAddress.getAddress().getHostAddress());
private Connector plainConnector(Jetty9Server server) { HttpConfiguration httpConfig = new HttpConfiguration(); httpConfig.setOutputBufferSize(systemEnvironment.get(SystemEnvironment.RESPONSE_BUFFER_SIZE)); httpConfig.setSendServerVersion(false); httpConfig.addCustomizer(new ForwardedRequestCustomizer()); ServerConnector httpConnector = new ServerConnector(server.getServer(), new HttpConnectionFactory(httpConfig)); httpConnector.setHost(systemEnvironment.getListenHost()); httpConnector.setPort(systemEnvironment.getServerPort()); httpConnector.setIdleTimeout(systemEnvironment.get(SystemEnvironment.IDLE_TIMEOUT)); return httpConnector; }
public ServerConnector createConnector( Server server, ListenSocketAddress address, JettyThreadCalculator jettyThreadCalculator, ConnectionFactory... httpFactories ) { int acceptors = jettyThreadCalculator.getAcceptors(); int selectors = jettyThreadCalculator.getSelectors(); ServerConnector connector = new ServerConnector( server, null, null, null, acceptors, selectors, httpFactories ); connector.setName( name ); connector.setConnectionFactories( Arrays.asList( httpFactories ) ); // TCP backlog, per socket, 50 is the default, consider adapting if needed connector.setAcceptQueueSize( 50 ); connector.setHost( address.getHostname() ); connector.setPort( address.getPort() ); return connector; } }
private AbstractConnector createConnector(InetSocketAddress address, Server server) { ServerConnector connector; JettyResourceFactory resourceFactory = getResourceFactory(); if (resourceFactory != null) { connector = new ServerConnector(server, resourceFactory.getExecutor(), resourceFactory.getScheduler(), resourceFactory.getByteBufferPool(), this.acceptors, this.selectors, new HttpConnectionFactory()); } else { connector = new ServerConnector(server, this.acceptors, this.selectors); } connector.setHost(address.getHostString()); connector.setPort(address.getPort()); for (ConnectionFactory connectionFactory : connector.getConnectionFactories()) { if (connectionFactory instanceof HttpConfiguration.ConnectionFactory) { ((HttpConfiguration.ConnectionFactory) connectionFactory) .getHttpConfiguration().setSendServerVersion(false); } } return connector; }
factories); connector.setPort(port); connector.setHost(bindHost); connector.setInheritChannel(inheritChannel); if (acceptQueueSize != null) {
connector.setHost(bindIp);
connector.setHost(bindIp);
LOGGER.info("Renegotiation Allowed: {}", goSSLConfig.isRenegotiationAllowed()); ServerConnector https = new ServerConnector(server, new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()), new HttpConnectionFactory(httpsConfig)); https.setHost(systemEnvironment.getListenHost()); https.setPort(systemEnvironment.getSslServerPort()); https.setIdleTimeout(systemEnvironment.get(SystemEnvironment.IDLE_TIMEOUT));