Struct actix_web_middleware_redirect_scheme::scheme::RedirectScheme

pub struct RedirectScheme {
    pub disable: bool,
    pub https_to_http: bool,
    pub temporary: bool,
    pub replacements: Vec<(String, String)>,
}

Middleware for actix-web which redirects between http and https requests with optional url string replacements.

Usage

extern crate actix_web_middleware_redirect_scheme;

use actix_web::{App, web, HttpResponse};
use actix_web_middleware_redirect_scheme::RedirectSchemeBuilder;

App::new()
    .wrap(RedirectSchemeBuilder::new().temporary().build())
    .route("/", web::get().to(|| HttpResponse::Ok()
                                    .content_type("text/plain")
                                    .body("Always HTTPS!")));

Fields

disable: bool

https_to_http: bool

temporary: bool

replacements: Vec<(String, String)>

Methods

impl RedirectScheme

pub fn simple(https_to_http: bool) -> Self

Creates a RedirectScheme middleware.

Usage

extern crate actix_web_middleware_redirect_scheme;

use actix_web::{App, web, HttpResponse};
use actix_web_middleware_redirect_scheme::RedirectScheme;

App::new()
    .wrap(RedirectScheme::simple(false))
    .route("/", web::get().to(|| HttpResponse::Ok()
                                    .content_type("text/plain")
                                    .body("Always HTTPS on non-default ports!")));

pub fn with_replacements<S: ToString>(
    https_to_http: bool,
    replacements: &[(S, S)]
) -> Self

Creates a RedirectScheme middleware which also performs string replacement on the final url. This is useful when not running on the default web and ssl ports (80 and 443) since we will need to change the development web port in the hostname to the development ssl port.

Usage

extern crate actix_web_middleware_redirect_scheme;

use actix_web::{App, web, HttpResponse};
use actix_web_middleware_redirect_scheme::RedirectScheme;

App::new()
    .wrap(RedirectScheme::with_replacements(false, &[(":8080", ":8443")]))
    .route("/", web::get().to(|| HttpResponse::Ok()
                                    .content_type("text/plain")
                                    .body("Always HTTPS on non-default ports!")));

Trait Implementations

impl Clone for RedirectScheme

fn clone(&self) -> RedirectScheme

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for RedirectScheme

fn default() -> RedirectScheme

Returns the "default value" for a type.

impl<S, B> Transform<S> for RedirectScheme where
    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static, 

type Request = ServiceRequest

Requests handled by the service.

type Response = ServiceResponse<B>

Responses given by the service.

type Error = Error

Errors produced by the service.

type InitError = ()

Errors produced while building a transform service.

type Transform = RedirectSchemeService<S>

The TransformService value created by this factory

type Future = Ready<Result<Self::Transform, Self::InitError>>

The future response value.

fn new_transform(&self, service: S) -> Self::Future

Creates and returns a new Transform component, asynchronously

fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, F, E> where
    F: Fn(Self::InitError) -> E + Clone, 

Map this transforms's factory error to a different error, returning a new transform service factory.