Refine search
private HandshakeInfo createHandshakeInfo(ServerWebExchange exchange, ServerHttpRequest request, @Nullable String protocol, Map<String, Object> attributes) { URI uri = request.getURI(); // Copy request headers, as they might be pooled and recycled by // the server implementation once the handshake HTTP exchange is done. HttpHeaders headers = new HttpHeaders(); headers.addAll(request.getHeaders()); Mono<Principal> principal = exchange.getPrincipal(); String logPrefix = exchange.getLogPrefix(); InetSocketAddress remoteAddress = request.getRemoteAddress(); return new HandshakeInfo(uri, headers, principal, protocol, remoteAddress, attributes, logPrefix); }
@Override protected Object resolveNamedValue(String name, MethodParameter parameter, ServerWebExchange exchange) { List<String> paramValues = exchange.getRequest().getQueryParams().get(name); Object result = null; if (paramValues != null) { result = (paramValues.size() == 1 ? paramValues.get(0) : paramValues); } return result; }
private String formatError(Throwable ex, ServerHttpRequest request) { String reason = ex.getClass().getSimpleName() + ": " + ex.getMessage(); String path = request.getURI().getRawPath(); return "Resolved [" + reason + "] for HTTP " + request.getMethod() + " " + path; }
private String formatRequest(ServerHttpRequest request) { String rawQuery = request.getURI().getRawQuery(); String query = StringUtils.hasText(rawQuery) ? "?" + rawQuery : ""; return "HTTP " + request.getMethod() + " \"" + request.getPath() + query + "\""; }
public DefaultServerHttpRequestBuilder(ServerHttpRequest original) { Assert.notNull(original, "ServerHttpRequest is required"); this.uri = original.getURI(); this.httpMethodValue = original.getMethodValue(); this.body = original.getBody(); this.httpHeaders = HttpHeaders.writableHttpHeaders(original.getHeaders()); this.cookies = new LinkedMultiValueMap<>(original.getCookies().size()); copyMultiValueMap(original.getCookies(), this.cookies); this.originalRequest = original; }
public MutatedServerHttpRequest(URI uri, @Nullable String contextPath, HttpHeaders headers, String methodValue, MultiValueMap<String, HttpCookie> cookies, @Nullable SslInfo sslInfo, Flux<DataBuffer> body, ServerHttpRequest originalRequest) { super(uri, contextPath, headers); this.methodValue = methodValue; this.cookies = cookies; this.remoteAddress = originalRequest.getRemoteAddress(); this.sslInfo = sslInfo != null ? sslInfo : originalRequest.getSslInfo(); this.body = body; this.originalRequest = originalRequest; }
@Override public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) { URI uri = request.getURI(); assertEquals("https", uri.getScheme()); assertNotNull(uri.getHost()); assertNotEquals(-1, uri.getPort()); assertNotNull(request.getRemoteAddress()); assertEquals("/foo", uri.getPath()); assertEquals("param=bar", uri.getQuery()); return Mono.empty(); } }
@Test public void xForwardedHeaders() throws Exception { HttpHeaders headers = new HttpHeaders(); headers.add("X-Forwarded-Host", "84.198.58.199"); headers.add("X-Forwarded-Port", "443"); headers.add("X-Forwarded-Proto", "https"); headers.add("foo", "bar"); ServerHttpRequest request = this.requestMutator.apply(getRequest(headers)); assertEquals(new URI("https://84.198.58.199/path"), request.getURI()); assertForwardedHeadersRemoved(request); }
@Test public void mutateRequest() throws Exception { SslInfo sslInfo = mock(SslInfo.class); ServerHttpRequest request = createHttpRequest("/").mutate().sslInfo(sslInfo).build(); assertSame(sslInfo, request.getSslInfo()); request = createHttpRequest("/").mutate().method(HttpMethod.DELETE).build(); assertEquals(HttpMethod.DELETE, request.getMethod()); String baseUri = "http://aaa.org:8080/a"; request = createHttpRequest(baseUri).mutate().uri(URI.create("http://bbb.org:9090/b")).build(); assertEquals("http://bbb.org:9090/b", request.getURI().toString()); request = createHttpRequest(baseUri).mutate().path("/b/c/d").build(); assertEquals("http://aaa.org:8080/b/c/d", request.getURI().toString()); request = createHttpRequest(baseUri).mutate().path("/app/b/c/d").contextPath("/app").build(); assertEquals("http://aaa.org:8080/app/b/c/d", request.getURI().toString()); assertEquals("/app", request.getPath().contextPath().value()); }
ServerHttpRequest request = exchange.getRequest(); HttpHeaders original = input; HttpHeaders updated = new HttpHeaders(); original.entrySet().stream() .forEach(entry -> updated.addAll(entry.getKey(), entry.getValue())); request.getRemoteAddress() != null && request.getRemoteAddress().getAddress() != null) String remoteAddr = request.getRemoteAddress().getAddress().getHostAddress(); List<String> xforwarded = original.get(X_FORWARDED_FOR_HEADER); String proto = request.getURI().getScheme(); if (isProtoEnabled()) { write(updated, X_FORWARDED_PROTO_HEADER, proto, isProtoAppend()); LinkedHashSet<URI> originalUris = exchange.getAttribute(GATEWAY_ORIGINAL_REQUEST_URL_ATTR); URI requestUri = exchange.getAttribute(GATEWAY_REQUEST_URL_ATTR); if(originalUri!=null && originalUri.getPath()!=null) { String prefix = originalUri.getPath(); String port = String.valueOf(request.getURI().getPort()); if (request.getURI().getPort() < 0) { port = String.valueOf(getDefaultPort(proto));
@Override public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { Route route = exchange.getAttribute(GATEWAY_ROUTE_ATTR); URI routeUri = route.getUri(); String scheme = routeUri.getScheme(); if (isAlreadyRouted(exchange) || !"forward".equals(scheme)) { return chain.filter(exchange); } exchange = exchange.mutate().request( exchange.getRequest().mutate().path(routeUri.getPath()).build()) .build(); return chain.filter(exchange); }
/** * Return the request path of the request. This is useful as HTML form * action target, also in combination with the original query string. */ public String getRequestPath() { return this.exchange.getRequest().getURI().getPath(); }
@Override public HttpHeaders filter(HttpHeaders input, ServerWebExchange exchange) { ServerHttpRequest request = exchange.getRequest(); HttpHeaders original = input; HttpHeaders updated = new HttpHeaders(); original.entrySet().stream() .filter(entry -> !entry.getKey().toLowerCase().equalsIgnoreCase(FORWARDED_HEADER)) .forEach(entry -> updated.addAll(entry.getKey(), entry.getValue())); List<Forwarded> forwardeds = parse(original.get(FORWARDED_HEADER)); URI uri = request.getURI(); String host = original.getFirst(HttpHeaders.HOST); Forwarded forwarded = new Forwarded() .put("host", host) .put("proto", uri.getScheme()); InetSocketAddress remoteAddress = request.getRemoteAddress(); if (remoteAddress != null) { String forValue = remoteAddress.getAddress().getHostAddress();
@Override public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) { Exception error = new UnsupportedOperationException(); String path = request.getURI().getPath(); if (path.endsWith("response-body-error")) { return response.writeWith(Mono.error(error)); } else if (path.endsWith("handling-error")) { return Mono.error(error); } else { return Mono.empty(); } } }
@Override public Mono<Void> handle(ServerWebExchange exchange) { if (exchange.getRequest().getURI().getPath().equals("/form-parts")) { return assertGetFormParts(exchange); } return Mono.error(new AssertionError()); }
/** * Apply and remove, or remove Forwarded type headers. * @param request the request */ @Override public ServerHttpRequest apply(ServerHttpRequest request) { if (hasForwardedHeaders(request)) { ServerHttpRequest.Builder builder = request.mutate(); if (!this.removeOnly) { URI uri = UriComponentsBuilder.fromHttpRequest(request).build(true).toUri(); builder.uri(uri); String prefix = getForwardedPrefix(request); if (prefix != null) { builder.path(prefix + uri.getPath()); builder.contextPath(prefix); } } removeForwardedHeaders(builder); request = builder.build(); } return request; }
@Override public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { URI requestUrl = exchange.getRequiredAttribute(GATEWAY_REQUEST_URL_ATTR); String scheme = requestUrl.getScheme(); if (isAlreadyRouted(exchange) || (!"http".equals(scheme) && !"https".equals(scheme))) { return chain.filter(exchange); ServerHttpRequest request = exchange.getRequest(); HttpMethod method = request.getMethod(); httpHeaders.addAll(request.getHeaders()); httpHeaders.remove(HttpHeaders.HOST); }); headersSpec = bodySpec.body(BodyInserters.fromDataBuffers(request.getBody())); } else { headersSpec = bodySpec; .flatMap(res -> { ServerHttpResponse response = exchange.getResponse(); response.getHeaders().putAll(res.headers().asHttpHeaders()); response.setStatusCode(res.statusCode());
private ResponseCookie initSessionCookie( ServerWebExchange exchange, String id, Duration maxAge) { ResponseCookie.ResponseCookieBuilder cookieBuilder = ResponseCookie.from(this.cookieName, id) .path(exchange.getRequest().getPath().contextPath().value() + "/") .maxAge(maxAge) .httpOnly(true) .secure("https".equalsIgnoreCase(exchange.getRequest().getURI().getScheme())) .sameSite("Lax"); if (this.cookieInitializer != null) { this.cookieInitializer.accept(cookieBuilder); } return cookieBuilder.build(); }
/** * Return the query string of the current request. This is useful for * building an HTML form action target in combination with the original * request path. */ public String getQueryString() { return this.exchange.getRequest().getURI().getQuery(); }
isBodyRequired = isBodyRequired || (adapter != null && !adapter.supportsEmpty()); ServerHttpRequest request = exchange.getRequest(); ServerHttpResponse response = exchange.getResponse(); MediaType contentType = request.getHeaders().getContentType(); MediaType mediaType = (contentType != null ? contentType : MediaType.APPLICATION_OCTET_STREAM); Object[] hints = extractValidationHints(bodyParam); logger.debug(exchange.getLogPrefix() + (contentType != null ? "Content-Type:" + contentType : "No Content-Type, using " + MediaType.APPLICATION_OCTET_STREAM)); validate(target, hints, bodyParam, bindingContext, exchange)); return Mono.just(adapter.fromPublisher(flux)); mono = mono.onErrorResume(ex -> Mono.error(handleReadError(bodyParam, ex))); if (isBodyRequired) { mono = mono.switchIfEmpty(Mono.error(() -> handleMissingBody(bodyParam))); HttpMethod method = request.getMethod(); if (contentType == null && method != null && SUPPORTED_METHODS.contains(method)) { Flux<DataBuffer> body = request.getBody().doOnNext(o -> {