private static Predicate handlePredicateNode(String contents, Node node, Map<String, PredicateBuilder> handlerBuilders, ExchangeAttributeParser parser) { if(node instanceof AndNode) { AndNode andNode = (AndNode)node; return Predicates.and(handlePredicateNode(contents, andNode.getLeft(), handlerBuilders, parser), handlePredicateNode(contents, andNode.getRight(), handlerBuilders, parser)); } else if(node instanceof OrNode) { OrNode orNode = (OrNode)node; return Predicates.or(handlePredicateNode(contents, orNode.getLeft(), handlerBuilders, parser), handlePredicateNode(contents, orNode.getRight(), handlerBuilders, parser)); } else if(node instanceof NotNode) { NotNode orNode = (NotNode)node; return Predicates.not(handlePredicateNode(contents, orNode.getNode(), handlerBuilders, parser)); } else if(node instanceof ExpressionNode) { return handlePredicateExpressionNode(contents, (ExpressionNode) node, handlerBuilders, parser); }else if(node instanceof OperatorNode) { switch (node.getToken().getToken()) { case TRUE: { return Predicates.truePredicate(); } case FALSE: { return Predicates.falsePredicate(); } } } throw error(contents, node.getToken().getPosition(), "unexpected node " + node); }
@Override public Predicate build(final Map<String, Object> config) { String[] path = (String[]) config.get("path"); return Predicates.suffixes(path); } }
/** * Creates a predicate that returns true if the request path ends with any of the provided suffixes. */ public static Predicate suffixes(final String... paths) { if(paths.length == 1) { return suffix(paths[0]); } final PathSuffixPredicate[] predicates = new PathSuffixPredicate[paths.length]; for (int i = 0; i < paths.length; ++i) { predicates[i] = new PathSuffixPredicate(paths[i]); } return or(predicates); }
private static Predicate[] getCompressionPredicates(Compression compression) { List<Predicate> predicates = new ArrayList<>(); predicates.add( new MaxSizePredicate((int) compression.getMinResponseSize().toBytes())); predicates.add(new CompressibleMimeTypePredicate(compression.getMimeTypes())); if (compression.getExcludedUserAgents() != null) { for (String agent : compression.getExcludedUserAgents()) { RequestHeaderAttribute agentHeader = new RequestHeaderAttribute( new HttpString(HttpHeaders.USER_AGENT)); predicates.add(Predicates.not(Predicates.regex(agentHeader, agent))); } } return predicates.toArray(new Predicate[0]); }
AccessLogService(String pattern, boolean extended, Predicate predicate) { this.pattern = pattern; this.extended = extended; this.path = null; this.pathRelativeTo = null; this.filePrefix = null; this.fileSuffix = null; this.useServerLog = true; this.rotate = false; //doesn't really matter this.predicate = predicate == null ? Predicates.truePredicate() : predicate; }
/** * Creates a predicate that returns true if any of the given paths match exactly. */ public static Predicate paths(final String... paths) { final PathMatchPredicate[] predicates = new PathMatchPredicate[paths.length]; for (int i = 0; i < paths.length; ++i) { predicates[i] = new PathMatchPredicate(paths[i]); } return or(predicates); }
public static HttpHandler createErrorContext(final String slot) throws ModuleLoadException { final ClassPathResourceManager cpresource = new ClassPathResourceManager(getClassLoader(Module.getCallerModuleLoader(), ERROR_MODULE, slot), ""); final io.undertow.server.handlers.resource.ResourceHandler handler = new io.undertow.server.handlers.resource.ResourceHandler(cpresource) .setAllowed(not(path("META-INF"))) .setDirectoryListingEnabled(false) .setCachable(Predicates.<HttpServerExchange>falsePredicate()); //we also need to setup the default resource redirect return new PredicateHandler(path("/"), new RedirectHandler(ExchangeAttributes.constant(ERROR_CONTEXT + DEFAULT_RESOURCE)), handler); }
static ResourceHandlerDefinition createStaticContentHandler(ResourceManager resource, String context) { final io.undertow.server.handlers.resource.ResourceHandler handler = new io.undertow.server.handlers.resource.ResourceHandler(resource) .setCacheTime(60 * 60 * 24 * 31) .setAllowed(not(path("META-INF"))) .setResourceManager(resource) .setDirectoryListingEnabled(false) .setCachable(not(suffixes(NOCACHE_JS, APP_HTML, INDEX_HTML))); // avoid clickjacking attacks: console must not be included in (i)frames SetHeaderHandler frameHandler = new SetHeaderHandler(handler, "X-Frame-Options", "SAMEORIGIN"); // we also need to setup the default resource redirect PredicateHandler predicateHandler = new PredicateHandler(path("/"), new RedirectHandler(ExchangeAttributes.constant(context + DEFAULT_RESOURCE)), frameHandler); return new ResourceHandlerDefinition(context, DEFAULT_RESOURCE, predicateHandler); }
public HttpHandler resolveHandlers() { String[] mappedServices = HandlerUtil.removePathTemplate(adminEndpoints); Predicate mappedPredicate = Predicates.prefixes(mappedServices); return Handlers.predicate(mappedPredicate, routingAdminHandler, controlPanel); }
ModelNode predicateNode = AccessLogDefinition.PREDICATE.resolveModelAttribute(context, model); if(predicateNode.isDefined()) { predicate = Predicates.parse(predicateNode.asString(), getClass().getClassLoader());
current = new ServletAuthenticationCallHandler(current); if(deploymentInfo.isDisableCachingForSecuredPages()) { current = Handlers.predicate(Predicates.authRequired(), Handlers.disableCache(current), current);
/** * Optionally wrap the given {@link HttpHandler} for HTTP compression support. * @param compression the HTTP compression configuration * @param httpHandler the HTTP handler to wrap * @return the wrapped HTTP handler if compression is enabled, or the handler itself */ public static HttpHandler configureCompression(Compression compression, HttpHandler httpHandler) { if (compression == null || !compression.getEnabled()) { return httpHandler; } ContentEncodingRepository repository = new ContentEncodingRepository(); repository.addEncodingHandler("gzip", new GzipEncodingProvider(), 50, Predicates.and(getCompressionPredicates(compression))); return new EncodingHandler(repository).setNext(httpHandler); }
AccessLogService(String pattern, String path, String pathRelativeTo, String filePrefix, String fileSuffix, boolean rotate, boolean extended, Predicate predicate) { this.pattern = pattern; this.path = path; this.pathRelativeTo = pathRelativeTo; this.filePrefix = filePrefix; this.fileSuffix = fileSuffix; this.rotate = rotate; this.extended = extended; this.useServerLog = false; this.predicate = predicate == null ? Predicates.truePredicate() : predicate; }
@Override public HttpHandler wrap(final HttpHandler handler) { //we only run this on REQUEST or ASYNC invocations return new PredicateHandler(Predicates.or(DispatcherTypePredicate.REQUEST, DispatcherTypePredicate.ASYNC), new JACCContextIdHandler(contextId, handler), handler); } };
static ResourceHandlerDefinition createConsoleHandler(String slot, String resource) throws ModuleLoadException { final ClassPathResourceManager cpresource = new ClassPathResourceManager(getClassLoader(Module.getCallerModuleLoader(), ERROR_MODULE, slot), ""); final io.undertow.server.handlers.resource.ResourceHandler handler = new io.undertow.server.handlers.resource.ResourceHandler(cpresource) .setAllowed(not(path("META-INF"))) .setResourceManager(cpresource) .setDirectoryListingEnabled(false) .setCachable(Predicates.<HttpServerExchange>falsePredicate()); //we also need to setup the default resource redirect PredicateHandler predicateHandler = new PredicateHandler(path("/"), new RedirectHandler(ExchangeAttributes.constant(CONTEXT + resource)), handler); return new ResourceHandlerDefinition(CONTEXT, resource, predicateHandler); }
public HttpHandler resolveHandlers() { String[] mappedServices = HandlerUtil.removedPathTemplate(adminEndpoints); Predicate mappedPredicate = Predicates.prefixes(mappedServices); return Handlers.predicate(mappedPredicate, routingAdminHandler, controlPanel); }
private EncodingHandler getGzipEncodeHandler(final DeploymentManager dm) throws ServletException{ // FROM: https://stackoverflow.com/questions/28295752/compressing-undertow-server-responses#28329810 final Predicate sizePredicate = Predicates.parse( "max-content-size[" + Long.toString( 5 * 1024 ) + "]" ); EncodingHandler eh = new EncodingHandler( new ContentEncodingRepository().addEncodingHandler( "gzip", new GzipEncodingProvider(), 50, sizePredicate ) .addEncodingHandler( "deflate", new DeflateEncodingProvider(), 51, sizePredicate ) ).setNext( dm.start() ); return eh; }
current = new ServletAuthenticationCallHandler(current); if(deploymentInfo.isDisableCachingForSecuredPages()) { current = Handlers.predicate(Predicates.authRequired(), Handlers.disableCache(current), current);
private static Predicate handlePredicateNode(String contents, Node node, Map<String, PredicateBuilder> handlerBuilders, ExchangeAttributeParser parser) { if(node instanceof AndNode) { AndNode andNode = (AndNode)node; return Predicates.and(handlePredicateNode(contents, andNode.getLeft(), handlerBuilders, parser), handlePredicateNode(contents, andNode.getRight(), handlerBuilders, parser)); } else if(node instanceof OrNode) { OrNode orNode = (OrNode)node; return Predicates.or(handlePredicateNode(contents, orNode.getLeft(), handlerBuilders, parser), handlePredicateNode(contents, orNode.getRight(), handlerBuilders, parser)); } else if(node instanceof NotNode) { NotNode orNode = (NotNode)node; return Predicates.not(handlePredicateNode(contents, orNode.getNode(), handlerBuilders, parser)); } else if(node instanceof ExpressionNode) { return handlePredicateExpressionNode(contents, (ExpressionNode) node, handlerBuilders, parser); }else if(node instanceof OperatorNode) { switch (node.getToken().getToken()) { case TRUE: { return Predicates.truePredicate(); } case FALSE: { return Predicates.falsePredicate(); } } } throw error(contents, node.getToken().getPosition(), "unexpected node " + node); }
public AccessLogHandler(final HttpHandler next, final AccessLogReceiver accessLogReceiver, final String formatString, ClassLoader classLoader) { this(next, accessLogReceiver, formatString, classLoader, Predicates.truePredicate()); }