com.github.mkopylec.charon.forwarding.interceptors.HttpResponse Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of charon-spring-webflux Show documentation
Reverse proxy implementation in form of Spring Boot starter
The newest version!
package com.github.mkopylec.charon.forwarding.interceptors;

import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatusCode;
import org.springframework.http.ResponseCookie;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.reactive.ClientHttpResponse;
import org.springframework.util.MultiValueMap;
import org.springframework.web.reactive.function.BodyExtractor;
import org.springframework.web.reactive.function.client.ClientResponse;
import org.springframework.web.reactive.function.client.ExchangeStrategies;
import org.springframework.web.reactive.function.client.WebClientResponseException;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.net.URI;
import java.util.List;
import java.util.Map;

import static com.github.mkopylec.charon.forwarding.RequestForwardingException.requestForwardingError;
import static com.github.mkopylec.charon.forwarding.Utils.copyHeaders;
import static org.springframework.web.reactive.function.client.ClientResponse.create;
import static reactor.core.publisher.Mono.empty;
import static reactor.core.publisher.Mono.just;

public class HttpResponse implements ClientResponse {

    private Mono body;
    private ClientResponse delegate;
    private HttpRequest request;

    public HttpResponse(HttpStatusCode status) {
        this(status, null);
    }

    public HttpResponse(HttpStatusCode status, HttpRequest request) {
        body = empty();
        delegate = create(status).build();
        this.request = request;
    }

    HttpResponse(ClientResponse response, HttpRequest request) {
        body = response.bodyToMono(byte[].class); // Releases connection
        delegate = response;
        this.request = request;
    }

    @Override
    public HttpStatusCode statusCode() {
        return delegate.statusCode();
    }

    public void setStatusCode(HttpStatusCode status) {
        delegate = delegate.mutate()
                .statusCode(status)
                .build();
    }

    @Override
    public Headers headers() {
        return delegate.headers();
    }

    public void setHeaders(HttpHeaders headers) {
        delegate = delegate.mutate()
                .headers(httpHeaders -> {
                    httpHeaders.clear();
                    httpHeaders.putAll(headers);
                })
                .build();
    }

    @Override
    public MultiValueMap cookies() {
        return delegate.cookies();
    }

    @Override
    public ExchangeStrategies strategies() {
        return delegate.strategies();
    }

    @Override
    public org.springframework.http.HttpRequest request() {
        return request != null ? new org.springframework.http.HttpRequest() {

            @Override
            public HttpMethod getMethod() {
                return request.method();
            }

            @Override
            public URI getURI() {
                return request.url();
            }

            @Override
            public HttpHeaders getHeaders() {
                return request.headers();
            }

            @Override
            public Map getAttributes() {
                return request.attributes();
            }
        } : null;
    }

    public Mono getBody() {
        return body;
    }

    public void setBody(byte[] body) {
        this.body = just(body);
        HttpHeaders rewrittenHeaders = copyHeaders(delegate.headers().asHttpHeaders());
        rewrittenHeaders.setContentLength(body.length);
        setHeaders(rewrittenHeaders);
    }

    @Override
    public  T body(BodyExtractor extractor) {
        throw requestForwardingError("Method not implemented");
    }

    @Override
    @SuppressWarnings("unchecked")
    public  Mono bodyToMono(Class elementClass) {
        if (byte[].class.isAssignableFrom(elementClass)) {
            return (Mono) getBody();
        }
        throw requestForwardingError("Method not implemented");
    }

    @Override
    public  Mono bodyToMono(ParameterizedTypeReference typeReference) {
        throw requestForwardingError("Method not implemented");
    }

    @Override
    public  Flux bodyToFlux(Class elementClass) {
        throw requestForwardingError("Method not implemented");
    }

    @Override
    public  Flux bodyToFlux(ParameterizedTypeReference typeReference) {
        throw requestForwardingError("Method not implemented");
    }

    @Override
    public Mono releaseBody() {
        return empty(); // Already released in constructor
    }

    @Override
    public  Mono> toEntity(Class bodyType) {
        throw requestForwardingError("Method not implemented");
    }

    @Override
    public  Mono> toEntity(ParameterizedTypeReference typeReference) {
        throw requestForwardingError("Method not implemented");
    }

    @Override
    public  Mono>> toEntityList(Class elementType) {
        throw requestForwardingError("Method not implemented");
    }

    @Override
    public  Mono>> toEntityList(ParameterizedTypeReference typeReference) {
        throw requestForwardingError("Method not implemented");
    }

    @Override
    public Mono> toBodilessEntity() {
        return delegate.toBodilessEntity();
    }

    @Override
    public Mono createException() {
        return delegate.createException();
    }

    @Override
    public  Mono createError() {
        return delegate.createError();
    }

    @Override
    public String logPrefix() {
        return delegate.logPrefix();
    }
}