Crate reverse_proxy_service 

reverse-proxy-service is tower Services that performs “reverse proxy” with various rewriting rules.

Internally these services use hyper::Client to send an incoming request to the another server. The connector for a client can be HttpConnector, HttpsConnector, or any ones whichever you want.

Examples

There are two types of services, OneshotService and ReusedService. The OneshotService owns the Client, while the ReusedService shares the Client via Arc.

General usage

use reverse_proxy_service::ReusedServiceBuilder;
use reverse_proxy_service::{ReplaceAll, ReplaceN};

use hyper::body::Body;
use http::Request;
use tower_service::Service as _;

let svc_builder = reverse_proxy_service::builder_http("example.com:1234").unwrap();

let req1 = Request::builder()
    .method("GET")
    .uri("https://myserver.com/foo/bar/foo")
    .body(Body::empty())
    .unwrap();

// Clones Arc<Client>
let mut svc1 = svc_builder.build(ReplaceAll("foo", "baz"));
// http://example.com:1234/baz/bar/baz
let _res = svc1.call(req1).await.unwrap();

let req2 = Request::builder()
    .method("POST")
    .uri("https://myserver.com/foo/bar/foo")
    .header("Content-Type", "application/x-www-form-urlencoded")
    .body(Body::from("key=value"))
    .unwrap();

let mut svc2 = svc_builder.build(ReplaceN("foo", "baz", 1));
// http://example.com:1234/baz/bar/foo
let _res = svc2.call(req2).await.unwrap();

In this example, the svc1 and svc2 shares the same Client, holding the Arc<Client>s inside them.

For more information of rewriting rules (ReplaceAll, ReplaceN etc.), see the documentations of rewrite.

With axum

use reverse_proxy_service::ReusedServiceBuilder;
use reverse_proxy_service::{TrimPrefix, AppendSuffix, Static};

use axum::Router;

#[tokio::main]
async fn main() {
    let host1 = reverse_proxy_service::builder_http("example.com").unwrap();
    let host2 = reverse_proxy_service::builder_http("example.net:1234").unwrap();

    let app = Router::new()
        .route_service("/healthcheck", host1.build(Static("/")))
        .route_service("/users/*path", host1.build(TrimPrefix("/users")))
        .route_service("/posts", host2.build(AppendSuffix("/")));

    axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
        .serve(app.into_make_service())
        .await
        .unwrap();
}

Return Types

The return type (Future::Output) of ReusedService and OneshotService is Result<Result<Response, Error>, Infallible>. This is because axum’s Router accepts only such Services.

The Error type implements IntoResponse if you enable the axumfeature. It returns an empty body, with the status code INTERNAL_SERVER_ERROR. The description of this error will be logged out at error level in the into_response() method.

Features

By default only http1 is enabled.

• http1: uses hyper/http1
• http2: uses hyper/http2
• https: alias to nativetls
• nativetls: uses the hyper-tls crate
• rustls: alias to rustls-webpki-roots
• rustls-webpki-roots: uses the hyper-rustls crate, with the feature webpki-roots
• rustls-native-roots: uses the hyper-rustls crate, with the feature rustls-native-certs
• rustls-http2: http2 plus rustls, and rustls/http2 is enabled
• axum: implements IntoResponse for Error

You must turn on either http1or http2. You cannot use the services if, for example, only the https feature is on.

Through this document, we use rustls to mean any of rustls* features unless otherwise specified.

Re-exports

pub use rewrite::*;

Modules

clienthttp1 or http2

Includes helper functions to build Clients, and some re-exports from hyper::client or hyper_tls.

rewrite

A PathRewriter instance defines a rule to rewrite the request path.

Structs

OneshotServicehttp1 or http2

A Service<Request<B>> that sends a request and returns the response, owning a Client.

ReusedServicehttp1 or http2

A Service<Request<B>> that sends a request and returns the response, sharing a Client.

ReusedServiceBuilderhttp1 or http2

The return type of builder(), builder_http() and builder_https().

RevProxyFuture

Enums

Error

Functions

builderhttp1 or http2

Builder of ReusedService.

builder_httphttp1 or http2

Builder of ReusedService, with client::http_default().

builder_https(http1 or http2) and (https or nativetls)

Builder of ReusedService, with client::https_default().

builder_nativetls(http1 or http2) and nativetls

Builder of ReusedService, with client::nativetls_default().

builder_rustls(http1 or http2) and rustls

Builder of ReusedService, with client::rustls_default().