io.undertow.attribute.ExchangeAttribute Java Examples

protected ExchangeAttribute getServerToClientElement(
        PatternTokenizer tokenizer) throws IOException {
    if (tokenizer.hasSubToken()) {
        String token = tokenizer.getToken();
        if ("status".equals(token)) {
            return ResponseCodeAttribute.INSTANCE;
        } else if ("comment".equals(token)) {
            return new ConstantExchangeAttribute("?");
        }
    } else if (tokenizer.hasParameter()) {
        String parameter = tokenizer.getParameter();
        if (parameter == null) {
            UndertowLogger.ROOT_LOGGER.extendedAccessLogMissingClosing();
            return null;
        }
        return new QuotingExchangeAttribute(new ResponseHeaderAttribute(new HttpString(parameter)));
    }
    UndertowLogger.ROOT_LOGGER.extendedAccessLogCannotDecode(tokenizer.getRemains());
    return null;
}
 

@Override
public HandlerWrapper build(final Map<String, Object> config) {
    final ExchangeAttribute value = (ExchangeAttribute) config.get("value");
    final String header = (String) config.get("header");

    return new HandlerWrapper() {
        @Override
        public HttpHandler wrap(HttpHandler handler) {
            return new SetHeaderHandler(handler, header, value);
        }
    };
}
 

@Override
public ExchangeAttribute build(final String token) {
    if (token.equals(REQUEST_LINE) || token.equals(REQUEST_LINE_SHORT)) {
        return ServletRequestLineAttribute.INSTANCE;
    }
    return null;
}
 

@Override
public Predicate build(final Map<String, Object> config) {
    ExchangeAttribute value = (ExchangeAttribute) config.get("value");
    if(value == null) {
        value = ExchangeAttributes.relativePath();
    }
    return new DirectoryPredicate(value);
}
 

@Override
public ExchangeAttribute build(final String token) {
    if (token.startsWith("%{sc,") && token.endsWith("}")) {
        final String attributeName = token.substring(5, token.length() - 1);
        return new ServletContextAttribute(attributeName);
    }
    return null;
}
 

@Override
public ExchangeAttribute build(final String token) {
    if (token.startsWith("%{s,") && token.endsWith("}")) {
        final String attributeName = token.substring(4, token.length() - 1);
        return new ServletSessionAttribute(attributeName);
    }
    return null;
}
 

@Override
public Predicate build(final Map<String, Object> config) {
    ExchangeAttribute match = (ExchangeAttribute) config.get("match");
    if (match == null) {
        match = ExchangeAttributes.relativePath();
    }
    String value = (String) config.get("value");
    return new PathTemplatePredicate(value, match);
}
 

@Override
public Map<String, Class<?>> parameters() {
    final Map<String, Class<?>> params = new HashMap<>();
    params.put("value", ExchangeAttribute.class);
    params.put("require-content", Boolean.class);
    return params;
}
 

@Override
public Map<String, Class<?>> parameters() {
    final Map<String, Class<?>> params = new HashMap<>();
    params.put("value", ExchangeAttribute.class);
    params.put("search", String[].class);
    return params;
}
 

protected ExchangeAttribute getProxyElement(PatternTokenizer tokenizer)
        throws IOException {
    String token = null;
    if (tokenizer.hasSubToken()) {
        tokenizer.getToken();
        return new ConstantExchangeAttribute("-");
    } else if (tokenizer.hasParameter()) {
        tokenizer.getParameter();
        return new ConstantExchangeAttribute("-");
    }
    UndertowLogger.ROOT_LOGGER.extendedAccessLogCannotDecode(token);
    return null;
}
 

private static Object coerceToType(final String string, final Token token, final Class<?> type, final ExchangeAttributeParser attributeParser) {
    if (type.isArray()) {
        Object array = Array.newInstance(type.getComponentType(), 1);
        Array.set(array, 0, coerceToType(string, token, type.getComponentType(), attributeParser));
        return array;
    }

    if (type == String.class) {
        return token.getToken();
    } else if (type.equals(Boolean.class) || type.equals(boolean.class)) {
        return Boolean.valueOf(token.getToken());
    } else if (type.equals(Byte.class) || type.equals(byte.class)) {
        return Byte.valueOf(token.getToken());
    } else if (type.equals(Character.class) || type.equals(char.class)) {
        if (token.getToken().length() != 1) {
            throw error(string, token.getPosition(), "Cannot coerce " + token.getToken() + " to a Character");
        }
        return Character.valueOf(token.getToken().charAt(0));
    } else if (type.equals(Short.class) || type.equals(short.class)) {
        return Short.valueOf(token.getToken());
    } else if (type.equals(Integer.class) || type.equals(int.class)) {
        return Integer.valueOf(token.getToken());
    } else if (type.equals(Long.class) || type.equals(long.class)) {
        return Long.valueOf(token.getToken());
    } else if (type.equals(Float.class) || type.equals(float.class)) {
        return Float.valueOf(token.getToken());
    } else if (type.equals(Double.class) || type.equals(double.class)) {
        return Double.valueOf(token.getToken());
    } else if (type.equals(ExchangeAttribute.class)) {
        return attributeParser.parse(token.getToken());
    }

    return token.getToken();
}
 

@Override
public ExchangeAttribute build(final String token) {
    if (token.startsWith("%{r,") && token.endsWith("}")) {
        final String attributeName = token.substring(4, token.length() - 1);
        return new ServletRequestAttribute(attributeName);
    }
    return null;
}
 

@Override
public Map<String, Class<?>> parameters() {
    Map<String, Class<?>> params = new HashMap<>();
    params.put("value", ExchangeAttribute.class);

    return params;
}
 

@Override
public Map<String, Class<?>> parameters() {
    Map<String, Class<?>> params = new HashMap<>();
    params.put("acl", String[].class);
    params.put("default-allow", boolean.class);
    params.put("attribute", ExchangeAttribute.class);
    return params;
}
 

@Override
public Predicate build(final Map<String, Object> config) {
    ExchangeAttribute value = (ExchangeAttribute) config.get("value");
    Boolean requireContent = (Boolean)config.get("require-content");
    if(value == null) {
        value = ExchangeAttributes.relativePath();
    }
    return new FilePredicate(value, requireContent == null ? false : requireContent);
}
 

@Override
public ExchangeAttribute build(final String token) {
    if (token.equals(SESSION_ID) || token.equals(SESSION_ID_SHORT)) {
        return INSTANCE;
    }
    return null;
}
 

@Override
public ExchangeAttribute build(final String token) {
    if (token.equals(REQUEST_LOCALE)) {
        return INSTANCE;
    }
    return null;
}
 

ProxyAction(final ProxyConnection clientConnection, final HttpServerExchange exchange, Map<HttpString, ExchangeAttribute> requestHeaders,
            boolean rewriteHostHeader, boolean reuseXForwarded, ProxyClientHandler proxyClientHandler, Predicate idempotentPredicate) {
    this.clientConnection = clientConnection;
    this.exchange = exchange;
    this.requestHeaders = requestHeaders;
    this.rewriteHostHeader = rewriteHostHeader;
    this.reuseXForwarded = reuseXForwarded;
    this.proxyClientHandler = proxyClientHandler;
    this.idempotentPredicate = idempotentPredicate;
}
 

@Override
public Predicate build(final Map<String, Object> config) {
    ExchangeAttribute value = (ExchangeAttribute) config.get("value");
    if(value == null) {
        value = ExchangeAttributes.relativePath();
    }
    Boolean fullMatch = (Boolean) config.get("full-match");
    Boolean caseSensitive = (Boolean) config.get("case-sensitive");
    String pattern = (String) config.get("pattern");
    return new RegularExpressionPredicate(pattern, value, fullMatch == null ? false : fullMatch, caseSensitive == null ? true : caseSensitive);
}
 

ProxyHandler(Builder builder) {
    this.proxyClient = builder.proxyClient;
    this.maxRequestTime = builder.maxRequestTime;
    this.next = builder.next;
    this.rewriteHostHeader = builder.rewriteHostHeader;
    this.reuseXForwarded = builder.reuseXForwarded;
    this.maxConnectionRetries = builder.maxConnectionRetries;
    this.idempotentRequestPredicate = builder.idempotentRequestPredicate;
    for(Map.Entry<HttpString, ExchangeAttribute> e : builder.requestHeaders.entrySet()) {
        requestHeaders.put(e.getKey(), e.getValue());
    }
}
 

@Override
public Map<String, Class<?>> parameters() {
    final Map<String, Class<?>> params = new HashMap<>();
    params.put("pattern", String.class);
    params.put("value", ExchangeAttribute.class);
    params.put("full-match", Boolean.class);
    params.put("case-sensitive", Boolean.class);
    return params;
}
 

@Override
public Predicate build(final Map<String, Object> config) {
    ExchangeAttribute value = (ExchangeAttribute) config.get("value");
    if(value == null) {
        value = ExchangeAttributes.relativePath();
    }
    Boolean fullMatch = (Boolean) config.get("full-match");
    Boolean caseSensitive = (Boolean) config.get("case-sensitive");
    String pattern = (String) config.get("pattern");
    return new RegularExpressionPredicate(pattern, value, fullMatch == null ? false : fullMatch, caseSensitive == null ? true : caseSensitive);
}
 

@Override
public Map<String, Class<?>> parameters() {
    final Map<String, Class<?>> params = new HashMap<>();
    params.put("value", String.class);
    params.put("match", ExchangeAttribute.class);
    return params;
}
 

@Override
public HandlerWrapper build(final Map<String, Object> config) {
    final ExchangeAttribute value = (ExchangeAttribute) config.get("value");

    return new HandlerWrapper() {
        @Override
        public HttpHandler wrap(HttpHandler handler) {
            return new SetAttributeHandler(handler, ExchangeAttributes.relativePath(), value);
        }
    };
}
 

@Override
public ExchangeAttribute build(final String token) {
    if (token.equals(REQUESTED_SESSION_ID_VALID)) {
        return INSTANCE;
    }
    return null;
}
 

public AccessLogHandler(final HttpHandler next, final AccessLogReceiver accessLogReceiver, String formatString, final ExchangeAttribute attribute, Predicate predicate) {
    this.next = next;
    this.accessLogReceiver = accessLogReceiver;
    this.predicate = predicate;
    this.formatString = handleCommonNames(formatString);
    this.tokens = attribute;
}
 

protected ExchangeAttribute getServletRequestElement(String parameter) {
    if ("authType".equals(parameter)) {
        return new SubstituteEmptyWrapper.SubstituteEmptyAttribute(AuthenticationTypeExchangeAttribute.INSTANCE,"-");
    } else if ("remoteUser".equals(parameter)) {
        return new SubstituteEmptyWrapper.SubstituteEmptyAttribute(RemoteUserAttribute.INSTANCE,"-");
    } else if ("requestedSessionId".equals(parameter)) {
        return parser.parse("%{REQUESTED_SESSION_ID}");
    } else if ("requestedSessionIdFromCookie".equals(parameter)) {
        return parser.parse("%{REQUESTED_SESSION_ID_FROM_COOKIE}");
    } else if ("requestedSessionIdValid".equals(parameter)) {
        return parser.parse("%{REQUESTED_SESSION_ID_VALID}");
    } else if ("contentLength".equals(parameter)) {
        return new QuotingExchangeAttribute(new RequestHeaderAttribute(Headers.CONTENT_LENGTH));
    } else if ("characterEncoding".equals(parameter)) {
        return parser.parse("%{REQUEST_CHARACTER_ENCODING}");
    } else if ("locale".equals(parameter)) {
        return parser.parse("%{REQUEST_LOCALE}");
    } else if ("protocol".equals(parameter)) {
        return RequestProtocolAttribute.INSTANCE;
    } else if ("scheme".equals(parameter)) {
        return RequestSchemeAttribute.INSTANCE;
    } else if ("secure".equals(parameter)) {
        return SecureExchangeAttribute.INSTANCE;
    }
    UndertowLogger.ROOT_LOGGER.extendedAccessLogCannotDecodeXParamValue(parameter);
    return null;
}
 

protected ExchangeAttribute getProxyElement(PatternTokenizer tokenizer)
        throws IOException {
    String token = null;
    if (tokenizer.hasSubToken()) {
        tokenizer.getToken();
        return new ConstantExchangeAttribute("-");
    } else if (tokenizer.hasParameter()) {
        tokenizer.getParameter();
        return new ConstantExchangeAttribute("-");
    }
    UndertowLogger.ROOT_LOGGER.extendedAccessLogCannotDecode(token);
    return null;
}
 

protected ExchangeAttribute getServletRequestElement(String parameter) {
    if ("authType".equals(parameter)) {
        return new SubstituteEmptyWrapper.SubstituteEmptyAttribute(AuthenticationTypeExchangeAttribute.INSTANCE,"-");
    } else if ("remoteUser".equals(parameter)) {
        return new SubstituteEmptyWrapper.SubstituteEmptyAttribute(RemoteUserAttribute.INSTANCE,"-");
    } else if ("requestedSessionId".equals(parameter)) {
        return parser.parse("%{REQUESTED_SESSION_ID}");
    } else if ("requestedSessionIdFromCookie".equals(parameter)) {
        return parser.parse("%{REQUESTED_SESSION_ID_FROM_COOKIE}");
    } else if ("requestedSessionIdValid".equals(parameter)) {
        return parser.parse("%{REQUESTED_SESSION_ID_VALID}");
    } else if ("contentLength".equals(parameter)) {
        return new QuotingExchangeAttribute(new RequestHeaderAttribute(HttpHeaderNames.CONTENT_LENGTH));
    } else if ("characterEncoding".equals(parameter)) {
        return parser.parse("%{REQUEST_CHARACTER_ENCODING}");
    } else if ("locale".equals(parameter)) {
        return parser.parse("%{REQUEST_LOCALE}");
    } else if ("getProtocol".equals(parameter)) {
        return RequestProtocolAttribute.INSTANCE;
    } else if ("scheme".equals(parameter)) {
        return RequestSchemeAttribute.INSTANCE;
    } else if ("secure".equals(parameter)) {
        return SecureExchangeAttribute.INSTANCE;
    }
    UndertowLogger.ROOT_LOGGER.extendedAccessLogCannotDecodeXParamValue(parameter);
    return null;
}
 

@Override
public ExchangeAttribute build(final String token) {
    if (token.startsWith("%{rp,") && token.endsWith("}")) {
        final String attributeName = token.substring(5, token.length() - 1);
        return new ServletRequestParameterAttribute(attributeName);
    }
    return null;
}