org.eclipse.jetty.servlet.ServletHandler Java Examples

private ServletHandler buildServletHandler(Repository repo) {
    GitServlet gitServlet = new GitServlet();
    gitServlet.setRepositoryResolver(new SinglePredefinedRepoResolver<>(repo));

    ServletHolder holder = new ServletHolder(gitServlet);
    ServletHandler servletHandler = new ServletHandler();
    servletHandler.addServletWithMapping(holder, "/*");
    return servletHandler;
}
 

/**
 * Starts the server.
 * 
 * @param host
 *            the host to listen
 * @param port
 *            the port to listen
 * @throws Exception
 *             if the server can't be started
 */
public void start(String host, int port) throws Exception {
    server = new Server();

    @SuppressWarnings("resource")
    final ServerConnector connector = new ServerConnector(server);
    connector.setPort(port);
    connector.setHost(host);
    server.setConnectors(new Connector[] {connector });

    final ServletHandler servletHandler = new ServletHandler();
    server.setHandler(servletHandler);
    servletHandler.addServletWithMapping(AddInServlet.class, "/*");

    final HandlerList handlers = new HandlerList();
    handlers.setHandlers(new Handler[] {servletHandler, new DefaultHandler() });
    server.setHandler(handlers);

    server.start();
}
 

@Override
public void start() throws Exception {
  if (!livenessEnabled) {
    logger.info("Liveness service disabled");
    return;
  }
  final ServerConnector serverConnector = new ServerConnector(embeddedLivenessJetty, NUM_ACCEPTORS, NUM_SELECTORS);
  serverConnector.setPort(config.getInt(DremioConfig.LIVENESS_PORT));
  serverConnector.setHost(LOOPBACK_INTERFACE);
  serverConnector.setAcceptQueueSize(ACCEPT_QUEUE_BACKLOG);
  embeddedLivenessJetty.addConnector(serverConnector);

  ServletHandler handler = new ServletHandler();
  embeddedLivenessJetty.setHandler(handler);

  handler.addServletWithMapping(new ServletHolder(new LivenessServlet()), "/live");
  handler.addServletWithMapping(new ServletHolder(createMetricsServlet()), "/metrics");

  embeddedLivenessJetty.start();
  livenessPort = serverConnector.getLocalPort();
  logger.info("Started liveness service on port {}", livenessPort);
}
 

public static void main(String[] args) throws Exception {
  initWeixin();

  Server server = new Server(8080);

  ServletHandler servletHandler = new ServletHandler();
  server.setHandler(servletHandler);

  ServletHolder endpointServletHolder = new ServletHolder(new WxCpEndpointServlet(wxCpConfigStorage, wxCpService, wxCpMessageRouter));
  servletHandler.addServletWithMapping(endpointServletHolder, "/*");

  ServletHolder oauthServletHolder = new ServletHolder(new WxCpOAuth2Servlet(wxCpService));
  servletHandler.addServletWithMapping(oauthServletHolder, "/oauth2/*");

  server.start();
  server.join();
}
 

public static void main(String[] args) throws Exception {
  initWeixin();

  Server server = new Server(8080);

  ServletHandler servletHandler = new ServletHandler();
  server.setHandler(servletHandler);

  ServletHolder endpointServletHolder = new ServletHolder(
    new WxMpEndpointServlet(wxMpConfigStorage, wxMpService,
      wxMpMessageRouter));
  servletHandler.addServletWithMapping(endpointServletHolder, "/*");

  ServletHolder oauthServletHolder = new ServletHolder(
    new WxMpOAuth2Servlet(wxMpService));
  servletHandler.addServletWithMapping(oauthServletHolder, "/oauth2/*");

  server.start();
  server.join();
}
 

public static void main(String[] args) throws Exception {
    // Create a basic jetty server object that will listen on port 8080.  Note that if you set this to port 0
    // then a randomly available port will be assigned that you can either look in the logs for the port,
    // or programmatically obtain it for use in test cases.
    Server server = new Server(8080);

    // The ServletHandler is a dead simple way to create a context handler that is backed by an instance of a
    // Servlet.  This handler then needs to be registered with the Server object.
    ServletHandler handler = new ServletHandler();
    server.setHandler(handler);

    // Passing in the class for the servlet allows jetty to instantite an instance of that servlet and mount it
    // on a given context path.

    // !! This is a raw Servlet, not a servlet that has been configured through a web.xml or anything like that !!
    handler.addServletWithMapping(HelloServlet.class, "/*");
    handler.addServletWithMapping(SimpleResponseServlet.class, "/servlet/SimpleResponse");

    // Start things up! By using the server.join() the server thread will join with the current thread.
    // See "http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Thread.html#join()" for more details.
    server.start();
    server.join();
}
 

public HttpSseServer start(int port, Consumer<MyEventSource> consumer) {
    server = new Server(port);
    ServletHandler handler = new ServletHandler();
    ServletHolder holder = new ServletHolder(new MyEventSourceServlet(consumer));
    handler.addServletWithMapping(holder, "/*");
    server.setHandler(handler);

    try {
        server.start();
        LOG.debug("started");
    }
    catch (Exception e) {
        throw new RuntimeException("Failed to start SSE HTTP server", e);
    }
    return this;
}
 

/**
 * Start Metric Server.
 *
 * @return the metric server.
 */
private Server startRestMetricServer() {
  final Server server = new Server(REST_SERVER_PORT);

  final ServletHandler servletHandler = new ServletHandler();
  server.setHandler(servletHandler);

  servletHandler.addServletWithMapping(JobMetricServlet.class, "/api/job");
  servletHandler.addServletWithMapping(TaskMetricServlet.class, "/api/task");
  servletHandler.addServletWithMapping(StageMetricServlet.class, "/api/stage");
  servletHandler.addServletWithMapping(AllMetricServlet.class, "/api");
  servletHandler.addServletWithMapping(WebSocketMetricServlet.class, "/api/websocket");

  try {
    server.start();
  } catch (final Exception e) {
    throw new MetricException("Failed to start REST API server: " + e);
  }

  return server;
}
 

@Override
public void setUp() throws Exception {
  // Initialize a Security handler and install our authenticatior.
  ServletHandler servletHandler = new ServletHandler();
  servletHandler.addServletWithMapping(new ServletHolder(new AuthServlet()) {}, "/*");
  securityHandler = new TestConstraintSecurityHandler();
  securityHandler.setHandler(servletHandler);
  AppEngineAuthentication.configureSecurityHandler(securityHandler, new MockAddressChecker());

  // Add authenticated paths to the security handler. Requests for those paths will be forwarded
  // to the authenticator with "mandatory=true".
  addConstraint(securityHandler, "/admin/*", "adminOnly", "admin");
  addConstraint(securityHandler, "/user/*", "userOnly", "*");
  addConstraint(securityHandler, "/_ah/login", "reserved", "*", "admin");
  securityHandler.doStart(); // Start the handler so the constraint map is compiled.

  // Use a local test version of the UserService to allow us to control login state.
  helper = new LocalServiceTestHelper(new LocalUserServiceTestConfig()).setUp();
}
 

public static void main(String[] args) throws Exception {
	Server server = new Server(8080);
	ServletHandler handler = new ServletHandler();
	server.setHandler(handler);
	handler.addServletWithMapping(SetCookieServlet.class, "/set");
	server.start();
	server.join();
}
 

public ExampleServer(Servlet servlet, String urlPattern) {
  ServletHolder holder = new ServletHolder(servlet);
  ServletHandler handler = new ServletHandler();
  handler.addServletWithMapping(holder, urlPattern);
  server = new Server(0);
  server.setHandler(handler);
}
 

private Server httpServer(CXFNonSpringServlet cxf) {
    Server server = new Server(Integer.parseInt(PORT));
    ServletHandler handler = new ServletHandler();
    server.setHandler(handler);
    handler.addServletWithMapping(new ServletHolder(cxf), "/*");
    return server;
}
 

protected HttpServerTestBody() {
    server = new Server(0);
    ServletHandler handler = new ServletHandler();
    handler.addServletWithMapping(servletHolder, "/*");
    server.setHandler(handler);
    try {
        server.start();
    } catch (Exception e) {
        LOGGER.error("[HttpServerTestBody] server failed to start.");
    }
}
 

private void createServer() throws Exception {
    server = new Server();
    final ContextHandlerCollection handlerCollection = new ContextHandlerCollection();

    final ServletContextHandler staticContext = new ServletContextHandler();
    staticContext.setContextPath("/");

    final ServletContextHandler atlasApiV2Context = new ServletContextHandler();
    atlasApiV2Context.setContextPath("/api/atlas/v2/");

    handlerCollection.setHandlers(new Handler[]{staticContext, atlasApiV2Context});

    server.setHandler(handlerCollection);

    final ResourceHandler resourceHandler = new ResourceHandler();
    resourceHandler.setBaseResource(Resource.newClassPathResource("public", false, false));
    staticContext.setHandler(resourceHandler);

    final ServletHandler servletHandler = new ServletHandler();
    atlasApiV2Context.insertHandler(servletHandler);

    httpConnector = new ServerConnector(server);
    httpConnector.setPort(21000);

    server.setConnectors(new Connector[]{httpConnector});

    servletHandler.addServletWithMapping(TypeDefsServlet.class, "/types/typedefs/");
    servletHandler.addServletWithMapping(EntityBulkServlet.class, "/entity/bulk/");
    servletHandler.addServletWithMapping(EntityGuidServlet.class, "/entity/guid/*");
    servletHandler.addServletWithMapping(SearchByUniqueAttributeServlet.class, "/entity/uniqueAttribute/type/*");
    servletHandler.addServletWithMapping(SearchBasicServlet.class, "/search/basic/");
    servletHandler.addServletWithMapping(LineageServlet.class, "/debug/lineage/");

    notificationServerEmulator = new AtlasNotificationServerEmulator();
}
 

JettyWrapper(String documentRootPath) {
    server = new Server(1234);
    ServletHandler handler = new ServletHandler();
    server.setHandler(handler);
    handler.addServletWithMapping(new ServletHolder(new IssueServlet(documentRootPath)), "/*");
    try {
        server.start();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

public static void main(String[] args) throws Exception {
	Server server = new Server(8080);
	ServletHandler handler = new ServletHandler();
	server.setHandler(handler);
	handler.addServletWithMapping(CookieServlet.class, "/cookies");
	server.start();
	server.join();
}
 

public MockSlackApiServer(int port) {
    this.port = port;
    server = new Server(this.port);
    ServletHandler handler = new ServletHandler();
    server.setHandler(handler);
    handler.addServletWithMapping(MockSlackApi.class, "/*");
}
 

/**
 * Add an internal servlet in the server, specifying whether or not to
 * protect with Kerberos authentication.
 * Note: This method is to be used for adding servlets that facilitate
 * internal communication and not for user facing functionality. For
 * servlets added using this method, filters (except internal Kerberos
 * filters) are not enabled.
 *
 * @param name The name of the servlet (can be passed as null)
 * @param pathSpec The path spec for the servlet
 * @param clazz The servlet class
 * @param requireAuth Require Kerberos authenticate to access servlet
 */
public void addInternalServlet(String name, String pathSpec,
                               Class<? extends HttpServlet> clazz, boolean requireAuth) {
  ServletHolder holder = new ServletHolder(clazz);
  if (name != null) {
    holder.setName(name);
  }
  // Jetty doesn't like the same path spec mapping to different servlets, so
  // if there's already a mapping for this pathSpec, remove it and assume that
  // the newest one is the one we want
  final ServletMapping[] servletMappings =
      webAppContext.getServletHandler().getServletMappings();
  for (ServletMapping servletMapping : servletMappings) {
    if (servletMapping.containsPathSpec(pathSpec)) {
      if (LOG.isDebugEnabled()) {
        LOG.debug("Found existing " + servletMapping.getServletName() +
                      " servlet at path " + pathSpec + "; will replace mapping" +
                      " with " + holder.getName() + " servlet");
      }
      ServletMapping[] newServletMappings =
          ArrayUtil.removeFromArray(servletMappings, servletMapping);
      webAppContext.getServletHandler()
          .setServletMappings(newServletMappings);
      break;
    }
  }
  webAppContext.addServlet(holder, pathSpec);

  if(requireAuth && UserGroupInformation.isSecurityEnabled()) {
    LOG.info("Adding Kerberos (SPNEGO) filter to " + name);
    ServletHandler handler = webAppContext.getServletHandler();
    FilterMapping fmap = new FilterMapping();
    fmap.setPathSpec(pathSpec);
    fmap.setFilterName(SPNEGO_FILTER);
    fmap.setDispatches(FilterMapping.ALL);
    handler.addFilterMapping(fmap);
  }
}
 

public static void main(String[] args) throws Exception {
       // Create a basic jetty server object that will listen on port 8080.  Note that if you set this to port 0
       // then a randomly available port will be assigned that you can either look in the logs for the port,
       // or programmatically obtain it for use in test cases.
       Server server = new Server(8080);
	HandlerCollection handlers = new HandlerCollection();
	server.setHandler(handlers);

       ServletHandler servlet = new ServletHandler();
	servlet.addServletWithMapping(HelloServlet.class, "/*");
	handlers.addHandler(servlet);

	handlers.addHandler(new DefaultHandler()); // must be after servlet it seems

	// log using NCSA (common log format)
	// http://en.wikipedia.org/wiki/Common_Log_Format
	NCSARequestLog requestLog = new NCSARequestLog();
	requestLog.setFilename("/tmp/yyyy_mm_dd.request.log");
	requestLog.setFilenameDateFormat("yyyy_MM_dd");
	requestLog.setRetainDays(90);
	requestLog.setAppend(true);
	requestLog.setExtended(true);
	requestLog.setLogCookies(false);
	requestLog.setLogTimeZone("GMT");
	RequestLogHandler requestLogHandler = new RequestLogHandler();
	requestLogHandler.setRequestLog(requestLog);
	handlers.addHandler(requestLogHandler);

	// Start things up! By using the server.join() the server thread will join with the current thread.
	// See "http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Thread.html#join()" for more details.
	server.start();
	server.join();
}
 

/**
 * Add the path spec to the filter path mapping.
 * @param pathSpec The path spec
 * @param webAppCtx The WebApplicationContext to add to
 */
protected void addFilterPathMapping(String pathSpec,
                                    ServletContextHandler webAppCtx) {
  ServletHandler handler = webAppCtx.getServletHandler();
  for(String name : filterNames) {
    FilterMapping fmap = new FilterMapping();
    fmap.setPathSpec(pathSpec);
    fmap.setFilterName(name);
    fmap.setDispatches(FilterMapping.ALL);
    handler.addFilterMapping(fmap);
  }
}
 

/**
 * Add an internal servlet in the server, specifying whether or not to
 * protect with Kerberos authentication.
 * Note: This method is to be used for adding servlets that facilitate
 * internal communication and not for user facing functionality. For
 * servlets added using this method, filters (except internal Kerberos
 * filters) are not enabled.
 *
 * @param name The name of the servlet (can be passed as null)
 * @param pathSpec The path spec for the servlet
 * @param clazz The servlet class
 * @param requireAuth Require Kerberos authenticate to access servlet
 */
public void addInternalServlet(String name, String pathSpec,
                               Class<? extends HttpServlet> clazz, boolean requireAuth) {
  ServletHolder holder = new ServletHolder(clazz);
  if (name != null) {
    holder.setName(name);
  }
  // Jetty doesn't like the same path spec mapping to different servlets, so
  // if there's already a mapping for this pathSpec, remove it and assume that
  // the newest one is the one we want
  final ServletMapping[] servletMappings =
      webAppContext.getServletHandler().getServletMappings();
  for (int i = 0; i < servletMappings.length; i++) {
    if (servletMappings[i].containsPathSpec(pathSpec)) {
      if (LOG.isDebugEnabled()) {
        LOG.debug("Found existing {} servlet at path {}; will replace mapping with {} servlet"
            , servletMappings[i].getServletName()
            , pathSpec
            , holder.getName());
      }
      ServletMapping[] newServletMappings =
          ArrayUtil.removeFromArray(servletMappings, servletMappings[i]);
      webAppContext.getServletHandler()
          .setServletMappings(newServletMappings);
      break;
    }
  }
  webAppContext.addServlet(holder, pathSpec);

  if(requireAuth && UserGroupInformation.isSecurityEnabled()) {
    LOG.info("Adding Kerberos (SPNEGO) filter to {}", name);
    ServletHandler handler = webAppContext.getServletHandler();
    FilterMapping fmap = new FilterMapping();
    fmap.setPathSpec(pathSpec);
    fmap.setFilterName(SPNEGO_FILTER);
    fmap.setDispatches(FilterMapping.ALL);
    handler.addFilterMapping(fmap);
  }
}
 

private void startServer() throws Exception {
  ServletHandler replicationHandler = new ServletHandler();
  ReplicationService service = new ReplicationService(Collections.singletonMap("s1", serverReplicator));
  replicationServlet = new ReplicationServlet(service);
  ServletHolder servlet = new ServletHolder(replicationServlet);
  replicationHandler.addServletWithMapping(servlet, ReplicationService.REPLICATION_CONTEXT + "/*");
  server = newHttpServer(replicationHandler);
  port = serverPort(server);
  host = serverHost(server);
}
 

public AuthTestMockServer(int port) {
    this.port = port;
    server = new Server(this.port);
    ServletHandler handler = new ServletHandler();
    server.setHandler(handler);
    handler.addServletWithMapping(AuthTestMockEndpoint.class, "/*");
}
 

public ScepServerContainer(int port, List<ScepServer> scepServers) throws Exception {
  Args.notEmpty(scepServers, "scepServers");
  server = new Server(port);
  ServletHandler handler = new ServletHandler();
  server.setHandler(handler);

  for (ScepServer m : scepServers) {
    ServletHolder servletHolder = new ServletHolder(m.getName(), m.getServlet());
    handler.addServletWithMapping(servletHolder, "/" + m.getName() + "/pkiclient.exe");
  }

  server.join();
}
 

public MockWebhookServer(int port) {
    this.port = port;
    server = new Server(this.port);
    ServletHandler handler = new ServletHandler();
    server.setHandler(handler);
    handler.addServletWithMapping(WebhookMockApi.class, "/*");
}
 

public MockSlackApiServer(int port) {
    this.port = port;
    server = new Server(this.port);
    ServletHandler handler = new ServletHandler();
    server.setHandler(handler);
    handler.addServletWithMapping(MockSlackApi.class, "/*");
}
 

public static void main(String[] args) throws Exception {
    Server server = new Server(3000);
    ServletHandler handler = new ServletHandler();
    server.setHandler(handler);
    handler.addServletWithMapping(SlackEventsServlet.class, "/slack/events");
    server.start();
    server.join();
}
 

public static void main(String[] args) throws Exception {
    Server server = new Server(3000);
    ServletHandler handler = new ServletHandler();
    server.setHandler(handler);
    handler.addServletWithMapping(SlackEventsServlet.class, "/slack/events");
    server.start();
    server.join();
}
 

public MockWebhookServer(int port) {
    this.port = port;
    server = new Server(this.port);
    ServletHandler handler = new ServletHandler();
    server.setHandler(handler);
    handler.addServletWithMapping(WebhookMockApi.class, "/*");
}
 

public MockSlackApiServer(int port) {
    this.port = port;
    server = new Server(this.port);
    ServletHandler handler = new ServletHandler();
    server.setHandler(handler);
    handler.addServletWithMapping(MockSlackApi.class, "/*");
}