/*
 * JBoss, Home of Professional Open Source.
 * Copyright 2014 Red Hat, Inc., and individual contributors
 * as indicated by the @author tags.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package io.undertow.predicate;

import io.undertow.UndertowLogger;
import io.undertow.server.HandlerWrapper;
import io.undertow.server.HttpHandler;
import io.undertow.server.HttpServerExchange;
import io.undertow.server.handlers.builder.HandlerBuilder;
import io.undertow.server.handlers.builder.PredicatedHandler;
import io.undertow.util.AttachmentKey;

import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

Handler that can deal with a large number of predicates. chaining together a large number of Holder instances will make the stack grow to large, so this class is used that can deal with a large number of predicates.
Author:Stuart Douglas
/** * Handler that can deal with a large number of predicates. chaining together a large number of {@link io.undertow.predicate.PredicatesHandler.Holder} * instances will make the stack grow to large, so this class is used that can deal with a large number of predicates. * * @author Stuart Douglas */
public class PredicatesHandler implements HttpHandler {
static done marker. If this is attached to the exchange it will drop out immediately.
/** * static done marker. If this is attached to the exchange it will drop out immediately. */
public static final AttachmentKey<Boolean> DONE = AttachmentKey.create(Boolean.class); public static final AttachmentKey<Boolean> RESTART = AttachmentKey.create(Boolean.class); private volatile Holder[] handlers = new Holder[0]; private volatile HttpHandler next; private final boolean outerHandler; //non-static, so multiple handlers can co-exist private final AttachmentKey<Integer> CURRENT_POSITION = AttachmentKey.create(Integer.class); public PredicatesHandler(HttpHandler next) { this.next = next; this.outerHandler = true; } public PredicatesHandler(HttpHandler next, boolean outerHandler) { this.next = next; this.outerHandler = outerHandler; } @Override public void handleRequest(HttpServerExchange exchange) throws Exception { final int length = handlers.length; Integer current = exchange.getAttachment(CURRENT_POSITION); do { int pos; if (current == null) { if (outerHandler) { exchange.removeAttachment(RESTART); exchange.removeAttachment(DONE); if (exchange.getAttachment(Predicate.PREDICATE_CONTEXT) == null) { exchange.putAttachment(Predicate.PREDICATE_CONTEXT, new TreeMap<String, Object>()); } } pos = 0; } else { //if it has been marked as done if (exchange.getAttachment(DONE) != null) { exchange.removeAttachment(CURRENT_POSITION); next.handleRequest(exchange); return; } pos = current; } for (; pos < length; ++pos) { final Holder handler = handlers[pos]; if (handler.predicate.resolve(exchange)) { exchange.putAttachment(CURRENT_POSITION, pos + 1); handler.handler.handleRequest(exchange); if(shouldRestart(exchange, current)) { break; } else { return; } } else if(handler.elseBranch != null) { exchange.putAttachment(CURRENT_POSITION, pos + 1); handler.elseBranch.handleRequest(exchange); if(shouldRestart(exchange, current)) { break; } else { return; } } } } while (shouldRestart(exchange, current)); next.handleRequest(exchange); } private boolean shouldRestart(HttpServerExchange exchange, Integer current) { return exchange.getAttachment(RESTART) != null && outerHandler && current == null; }
Adds a new predicated handler.

Params:
  • predicate –
  • handlerWrapper –
/** * Adds a new predicated handler. * <p> * * @param predicate * @param handlerWrapper */
public PredicatesHandler addPredicatedHandler(final Predicate predicate, final HandlerWrapper handlerWrapper, final HandlerWrapper elseBranch) { Holder[] old = handlers; Holder[] handlers = new Holder[old.length + 1]; System.arraycopy(old, 0, handlers, 0, old.length); HttpHandler elseHandler = elseBranch != null ? elseBranch.wrap(this) : null; handlers[old.length] = new Holder(predicate, handlerWrapper.wrap(this), elseHandler); this.handlers = handlers; return this; }
Adds a new predicated handler.

Params:
  • predicate –
  • handlerWrapper –
/** * Adds a new predicated handler. * <p> * * @param predicate * @param handlerWrapper */
public PredicatesHandler addPredicatedHandler(final Predicate predicate, final HandlerWrapper handlerWrapper) { this.addPredicatedHandler(predicate, handlerWrapper, null); return this; } public PredicatesHandler addPredicatedHandler(final PredicatedHandler handler) { return addPredicatedHandler(handler.getPredicate(), handler.getHandler(), handler.getElseHandler()); } public void setNext(HttpHandler next) { this.next = next; } public HttpHandler getNext() { return next; } private static final class Holder { final Predicate predicate; final HttpHandler handler; final HttpHandler elseBranch; private Holder(Predicate predicate, HttpHandler handler, HttpHandler elseBranch) { this.predicate = predicate; this.handler = handler; this.elseBranch = elseBranch; } } public static final class DoneHandlerBuilder implements HandlerBuilder { @Override public String name() { return "done"; } @Override public Map<String, Class<?>> parameters() { return Collections.emptyMap(); } @Override public Set<String> requiredParameters() { return Collections.emptySet(); } @Override public String defaultParameter() { return null; } @Override public HandlerWrapper build(Map<String, Object> config) { return new HandlerWrapper() { @Override public HttpHandler wrap(final HttpHandler handler) { return new HttpHandler() { @Override public void handleRequest(HttpServerExchange exchange) throws Exception { exchange.putAttachment(DONE, true); handler.handleRequest(exchange); } }; } }; } } public static final class RestartHandlerBuilder implements HandlerBuilder { private static final AttachmentKey<Integer> RESTART_COUNT = AttachmentKey.create(Integer.class); private static final int MAX_RESTARTS = Integer.getInteger("io.undertow.max_restarts", 1000); @Override public String name() { return "restart"; } @Override public Map<String, Class<?>> parameters() { return Collections.emptyMap(); } @Override public Set<String> requiredParameters() { return Collections.emptySet(); } @Override public String defaultParameter() { return null; } @Override public HandlerWrapper build(Map<String, Object> config) { return new HandlerWrapper() { @Override public HttpHandler wrap(final HttpHandler handler) { return new HttpHandler() { @Override public void handleRequest(HttpServerExchange exchange) throws Exception { Integer restarts = exchange.getAttachment(RESTART_COUNT); if(restarts == null) { restarts = 1; } else { restarts++; } exchange.putAttachment(RESTART_COUNT, restarts); if(restarts > MAX_RESTARTS) { throw UndertowLogger.ROOT_LOGGER.maxRestartsExceeded(MAX_RESTARTS); } exchange.putAttachment(RESTART, true); } }; } }; } } public static class Wrapper implements HandlerWrapper { private final List<PredicatedHandler> handlers; private final boolean outerHandler; public Wrapper(List<PredicatedHandler> handlers, boolean outerHandler) { this.handlers = handlers; this.outerHandler = outerHandler; } @Override public HttpHandler wrap(HttpHandler handler) { PredicatesHandler h = new PredicatesHandler(handler, outerHandler); for(PredicatedHandler pred : handlers) { h.addPredicatedHandler(pred.getPredicate(), pred.getHandler()); } return h; } } }