final Server server = new Server(port); final ContextHandlerCollection contexts = new ContextHandlerCollection(); final ServletContextHandler context = new ServletContextHandler(contexts, "/", ServletContextHandler.SESSIONS); final FilterHolder filterHolder = new FilterHolder(monitoringFilter); if (parameters != null) { for (final Map.Entry<Parameter, String> entry : parameters.entrySet()) { final net.bull.javamelody.Parameter parameter = entry.getKey(); final String value = entry.getValue(); filterHolder.setInitParameter(parameter.getCode(), value); context.addFilter(filterHolder, "/*", EnumSet.of(DispatcherType.INCLUDE, DispatcherType.REQUEST)); server.setHandler(handlers); server.start();
static void addCSRFFilter(ServletContextHandler ctxHandler, Configuration conf) { restCSRFEnabled = conf.getBoolean(REST_CSRF_ENABLED_KEY, REST_CSRF_ENABLED_DEFAULT); if (restCSRFEnabled) { Map<String, String> restCsrfParams = RestCsrfPreventionFilter .getFilterParams(conf, "hbase.rest-csrf."); FilterHolder holder = new FilterHolder(); holder.setName("csrf"); holder.setClassName(RestCsrfPreventionFilter.class.getName()); holder.setInitParameters(restCsrfParams); ctxHandler.addFilter(holder, PATH_SPEC_ANY, EnumSet.allOf(DispatcherType.class)); } }
private static FilterHolder getFilterHolder(String name, String classname, Map<String, String> parameters) { FilterHolder holder = new FilterHolder(); holder.setName(name); holder.setClassName(classname); if (parameters != null) { holder.setInitParameters(parameters); } return holder; }
/** * corsFilterHandle. * @return corsFilterHandle */ public static FilterHolder corsFilterHandle() { FilterHolder filterHolder = new FilterHolder(new CrossOriginFilter()); filterHolder.setInitParameter(CrossOriginFilter.ALLOWED_ORIGINS_PARAM, "*"); filterHolder.setInitParameter(CrossOriginFilter.ALLOWED_ORIGINS_PARAM, "GET, POST, PUT"); filterHolder.setInitParameter( CrossOriginFilter.ALLOWED_ORIGINS_PARAM, "X-Requested-With, X-Requested-By, Access-Control-Allow-Origin," + " Content-Type, Content-Length, Accept, Origin"); filterHolder.setInitParameter(CrossOriginFilter.ACCESS_CONTROL_ALLOW_ORIGIN_HEADER, "*"); return filterHolder; }
@Override public int init(int port, Onem2mPluginManager.Mode mode) { this.__port = port; this.instanceMode = mode; httpServer = new Server(__port); context = new ServletContextHandler(); context.setContextPath("/"); httpServer.setHandler(context); cors = context.addFilter(CrossOriginFilter.class, "*", EnumSet.of(DispatcherType.REQUEST)); cors.setInitParameter(CrossOriginFilter.ALLOWED_ORIGINS_PARAM, "*"); cors.setInitParameter(CrossOriginFilter.CHAIN_PREFLIGHT_PARAM, "false"); cors.setInitParameter(CrossOriginFilter.ALLOWED_METHODS_PARAM, "GET,POST,DELETE,PUT,HEAD"); cors.setInitParameter(CrossOriginFilter.ALLOWED_HEADERS_PARAM, "X-Requested-With,Content-Type,Accept,Origin,X-M2M-Origin,X-M2M-RI,X-M2M-NM,X-M2M-GID,X-M2M-RTU,X-M2M-OT,X-M2M-RST,X-M2M-RET,X-M2M-OET,X-M2M-EC,X-M2M-RSC"); cors.setInitParameter(CrossOriginFilter.EXPOSED_HEADERS_PARAM,"X-Requested-With,Content-Type,Accept,Origin,X-M2M-Origin,X-M2M-RI,X-M2M-NM,X-M2M-GID,X-M2M-RTU,X-M2M-OT,X-M2M-RST,X-M2M-RET,X-M2M-OET,X-M2M-EC,X-M2M-RSC"); onem2mHttpBaseHandler = new Onem2mHttpBaseHandler(this); context.addServlet(new ServletHolder(onem2mHttpBaseHandler), "/*"); try { httpServer.start(); LOG.info("startHttpServer: on port: {}", __port); } catch (Exception e) { e.printStackTrace(); LOG.info("Exception: {}", e.toString()); } return 0; }
private ContextHandlerCollection makeContextHandler(GuiceFilter guiceFilter) { ServletContextHandler handler = new ServletContextHandler(); handler.setContextPath(contextPath); handler.addFilter(new FilterHolder(guiceFilter), "/*", allOf(DispatcherType.class)); // note: registering a servlet for '/*' appears to be required, fails otherwise handler.addServlet(new ServletHolder(new InvalidRequestServlet()), "/*"); ContextHandlerCollection context = new ContextHandlerCollection(); context.setHandlers(new Handler[]{handler}); return context; }
ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS); context.setContextPath("/"); jettyServer.setHandler(context); .register(DefaultExceptionMapper.class); ServletHolder jerseyServlet = new ServletHolder(new ServletContainer(resourceConfig)); jerseyServlet.setInitOrder(0); context.addServlet(jerseyServlet, STORM_API_URL_PREFIX + "*"); addRequestContextFilter(context, DaemonConfig.UI_HTTP_CREDS_PLUGIN, conf); ServletHolder holderHome = new ServletHolder("static-home", DefaultServlet.class); holderHome.setInitParameter("dirAllowed","true"); holderHome.setInitParameter("pathInfoOnly","true"); context.addFilter(new FilterHolder(new HeaderResponseServletFilter(metricsRegistry)), "/*", EnumSet.allOf(DispatcherType.class)); context.addServlet(holderHome,"/*"); Utils.addShutdownHookWithForceKillIn1Sec(metricsRegistry::stopMetricsReporters); try { jettyServer.start(); jettyServer.join(); } catch (Throwable t) { LOG.error("Exception in UIServer: ", t);
urlPatterns = filterAnnotation.urlPatterns(); holder = _context.getServletHandler().newFilterHolder(new Source (Source.Origin.ANNOTATION, clazz.getName())); holder.setName(name); holder.setHeldClass(clazz); metaData.setOrigin(name+".filter.filter-class",filterAnnotation,clazz); holder.setDisplayName(filterAnnotation.displayName()); metaData.setOrigin(name+".filter.display-name",filterAnnotation,clazz); holder.setInitParameter(ip.name(), ip.value()); metaData.setOrigin(name+".filter.init-param."+ip.name(),ip,clazz); FilterMapping mapping = new FilterMapping(); mapping.setFilterName(holder.getName()); mapping.setPathSpecs(paths.toArray(new String[paths.size()])); holder.setAsyncSupported(filterAnnotation.asyncSupported()); metaData.setOrigin(name+".filter.async-supported",filterAnnotation,clazz); holder.setInitParameter(ip.name(), ip.value()); metaData.setOrigin(name+".filter.init-param."+ip.name(),ip,clazz); FilterMapping mapping = new FilterMapping(); mapping.setFilterName(holder.getName());
private static Server startHttp1() throws Exception { final Server server = new Server(0); final ServletHandler handler = new ServletHandler(); handler.addServletWithMapping(newServletHolder(thriftServlet), TSERVLET_PATH); handler.addServletWithMapping(newServletHolder(rootServlet), "/"); handler.addFilterWithMapping(new FilterHolder(new ConnectionCloseFilter()), "/*", EnumSet.of(DispatcherType.REQUEST)); server.setHandler(handler); for (Connector c : server.getConnectors()) { for (ConnectionFactory f : c.getConnectionFactories()) { for (String p : f.getProtocols()) { if (p.startsWith("h2c")) { fail("Attempted to create a Jetty server without HTTP/2 support, but failed: " + f.getProtocols()); } } } } server.start(); return server; }
@Test public void testConfiguredResolveFromRemoteAuthenticatingRepository() throws Exception { File testRepo = createMyModuleRepository("testConfiguredResolveFromRemoteAuthenticatingRepository"); File emptyRepo = Files.createTempDirectory("vertx").toFile(); emptyRepo.deleteOnExit(); Server server = createRemoteServer(testRepo); AuthFilter filter = AuthFilter.serverAuthenticator("username_value", "password_value"); ((ServletContextHandler) server.getHandler()).addFilter(new FilterHolder(filter), "/*", EnumSet.of(DispatcherType.REQUEST)); server.start(); servers.add(server); configureRepos(emptyRepo, "http://username_value:password_value@localhost:8080/"); vertx.deployVerticle("maven:my:module:1.0::my.serviceA", new DeploymentOptions(), onSuccess(id -> { assertTrue(filter.authenticated.get()); testComplete(); })); await(); }
protected Handler createAdminServlet(Server server, MutableServletContextHandler handler, MetricRegistry metrics, HealthCheckRegistry healthChecks) { configureSessionsAndSecurity(handler, server); handler.setServer(server); handler.getServletContext().setAttribute(MetricsServlet.METRICS_REGISTRY, metrics); handler.getServletContext().setAttribute(HealthCheckServlet.HEALTH_CHECK_REGISTRY, healthChecks); handler.addServlet(new NonblockingServletHolder(new AdminServlet()), "/*"); final String allowedMethodsParam = allowedMethods.stream() .collect(Collectors.joining(",")); handler.addFilter(AllowedMethodsFilter.class, "/*", EnumSet.of(DispatcherType.REQUEST)) .setInitParameter(AllowedMethodsFilter.ALLOWED_METHODS_PARAM, allowedMethodsParam); return handler; }
private void addPippoFilter(ServletContextHandler handler) { if (pippoFilterPath == null) { pippoFilterPath = "/*"; // default value } EnumSet<DispatcherType> dispatches = EnumSet.of(DispatcherType.REQUEST, DispatcherType.ERROR); FilterHolder pippoFilterHolder = new FilterHolder(getPippoFilter()); handler.addFilter(pippoFilterHolder, pippoFilterPath, dispatches); log.debug("Using pippo filter for path '{}'", pippoFilterPath); }
public TestWebServer(int port, String contextPath, String basePath) throws Exception { m_server = new Server(port); m_contextHandler = new ServletContextHandler(ServletContextHandler.SESSIONS); m_contextHandler.setContextPath("/"); ServletHolder holder = new ServletHolder(new DefaultServlet()); holder.setInitParameter("resourceBase", basePath); holder.setInitParameter("pathInfoOnly", "true"); holder.setInitParameter("acceptRanges", "true"); holder.setInitParameter("dirAllowed", "true"); m_contextHandler.addFilter(new FilterHolder(new HttpDumpFilter()), "/*", null); m_contextHandler.addServlet(holder, contextPath.concat(contextPath.endsWith("/") ? "*" : "/*")); m_server.setHandler(m_contextHandler); }
@Override public void initialize(Server server, Injector injector) final ServletContextHandler root = new ServletContextHandler(ServletContextHandler.SESSIONS); root.setInitParameter("org.eclipse.jetty.servlet.Default.dirAllowed", "false"); root.setInitParameter("org.eclipse.jetty.servlet.Default.redirectWelcome", "true"); root.setWelcomeFiles(new String[]{"index.html", "console.html"}); ServletHolder holderPwd = new ServletHolder("default", DefaultServlet.class); root.addServlet(holderPwd, "/"); root.addFilter(new FilterHolder(injector.getInstance(RedirectFilter.class)), "/*", null); server.setHandler(handlerList);
@Override public void deployConfig(WebApplicationContext wac, Filter... filters) { ServletHolder servletHolder = new ServletHolder(new DispatcherServlet(wac)); this.contextHandler = new ServletContextHandler(); this.contextHandler.addServlet(servletHolder, "/"); for (Filter filter : filters) { this.contextHandler.addFilter(new FilterHolder(filter), "/*", getDispatcherTypes()); } this.jettyServer.setHandler(this.contextHandler); }
holder = new ServletHolder(); holder.setHeldClass(ProxyServletImpl.class); holder.setInitParameter("maxThreads", Integer.toString(256)); holder.setInitParameter("prefix", pathSpec); holder.setInitParameter("proxyTo", proxyTo); holder.setInitParameter("hostHeader", hostHeader); servletContextHandler.addServlet(holder, pathSpec); if (allowedOrigins != null && allowedOrigins.length() != 0) FilterHolder filterHolder = servletContextHandler.addFilter( CrossOriginFilter.class, "/*", EnumSet.of(DispatcherType.REQUEST) ); filterHolder.setInitParameter( CrossOriginFilter.ALLOWED_ORIGINS_PARAM, allowedOrigins servletContextHandler.addFilter( TraceFilter.class, "/*", EnumSet.of(DispatcherType.REQUEST) );
protected void prepare() throws IOException { server = new Server(dc.getAppPort()); ServletContextHandler ctx = new ServletContextHandler(); ctx.setContextPath("/"); ctx.addServlet(DefaultServlet.class, "/*"); if (dc.containsKey("app-root")) { ctx.setResourceBase(dc.get("app-root")); } //ctx.setSessionHandler(new SessionHandler(new HashSessionManager())); FilterHolder fh = new FilterHolder(NutFilter.class); fh.setInitParameter("modules", dc.get("mainModuleClassName")); ctx.addFilter(fh, "/*", null); server.setHandler(ctx); }
@Override public void addFilter(String pathSpec, Filter filter) { if (webappContext == null) { try { initServer(); } catch (Exception e) { throw new IllegalStateException(e); } } webappContext.getServletHandler().addFilterWithMapping(new FilterHolder(filter), pathSpec, EnumSet.of(DispatcherType.REQUEST)); }
private static ServletContextHandler generateServletContextHandler( WebApplicationContext webappContext ) throws IOException { ServletContextHandler contextHandler = new ServletContextHandler(); contextHandler.setContextPath("/"); contextHandler.addServlet(new ServletHolder(new DispatcherServlet(webappContext)), "/*"); contextHandler.addEventListener(new ContextLoaderListener(webappContext)); FilterHolder requestTracingFilterHolder = contextHandler.addFilter( RequestTracingFilter.class, "/*", EnumSet.allOf(DispatcherType.class) ); requestTracingFilterHolder.setInitParameter(USER_ID_HEADER_KEYS_LIST_INIT_PARAM_NAME, USER_ID_HEADER_KEYS); return contextHandler; }
private static void addServlet(ServletContextHandler context, String s) { // Add the filter, and then use the provided FilterHolder to configure it FilterHolder cors = context.addFilter(CrossOriginFilter.class, "/*", EnumSet.of(DispatcherType.REQUEST)); cors.setInitParameter(CrossOriginFilter.ALLOWED_ORIGINS_PARAM, "*"); cors.setInitParameter(CrossOriginFilter.ACCESS_CONTROL_ALLOW_ORIGIN_HEADER, "*"); cors.setInitParameter(CrossOriginFilter.ALLOWED_METHODS_PARAM, "GET,PUT,POST,DELETE,HEAD,OPTIONS"); cors.setInitParameter(CrossOriginFilter.ALLOWED_HEADERS_PARAM, "X-Requested-With,Content-Type,Accept,Origin"); // this mirrors org.eclipse.winery.repository.rest\src\main\webapp\WEB-INF\web.xml ServletHolder h = context.addServlet(com.sun.jersey.spi.container.servlet.ServletContainer.class, "/*"); h.setInitParameter("com.sun.jersey.config.feature.FilterForwardOn404", "false"); h.setInitParameter("com.sun.jersey.config.feature.CanonicalizeURIPath", "true"); h.setInitParameter("com.sun.jersey.config.feature.DisableWADL", "true"); h.setInitParameter("com.sun.jersey.config.feature.NormalizeURI", "true"); h.setInitParameter("com.sun.jersey.config.feature.Redirect", "true"); h.setInitParameter("com.sun.jersey.api.json.POJOMappingFeature", "true"); h.setInitParameter("com.sun.jersey.config.property.resourceConfigClass", "org.eclipse.winery.repository.rest.server.WineryResourceConfig"); //context.addFilter(RequestLoggingFilter.class, "/*", EnumSet.of(DispatcherType.REQUEST)); context.addServlet(DefaultServlet.class, "/"); h.setInitOrder(1); }