Struct Embed

pub struct Embed<E, F>
where
    E: 'static + RustEmbed,
    F: FallbackHandler,
{ /* private fields */ }

Wrapper of rust_embed for actix.

Embed service must be registered with App::service() method.

rust_embed documentation: https://docs.rs/rust-embed/

Examples

use actix_web::App;
use actix_embed::Embed;
use rust_embed::RustEmbed;

#[derive(RustEmbed)]
#[folder = "testdata/"]
struct Assets;

let app = App::new()
    .service(Embed::new("/static", &Assets));

Implementations

impl<E> Embed<E, DefaultFallbackHandler>

where E: 'static + RustEmbed,

pub fn new<P: AsRef<str>>(mount_path: P, assets: &E) -> Self

Create new Embed instance.

Arguments

The first argument (mount_path) is the root URL at which the embed files are served. For example, /assets will serve files at example.com/assets/....

The second argument (assets) is the instance implements rust_embed::RustEmbed. For more information, see rust_embed documentation: https://docs.rs/rust-embed/

Notes

If the mount path is set as the root path /, services registered after this one will be inaccessible. Register more specific handlers and services before it.

impl<E, F> Embed<E, F>

where E: 'static + RustEmbed, F: FallbackHandler,

pub fn strict_slash(self, strict_slash: bool) -> Self

Set whether to ignore the trailing slash of the requested path.

Defaults to false.

If it’s set to true, then file ‘/dir/file’ cannot be accessed by request path ‘/dir/file/’.

pub fn index_file<P: AsRef<str>>(self, path: P) -> Self

Set the path of the index file.

By default there is no index file.

The index file is treated as the default file returned when a request visit the root directory.

pub fn fallback_handler<NF>(self, handler: NF) -> Embed<E, NF>

where NF: FallbackHandler,

Sets fallback handler which is used when no matched file could be found.

The default fallback handler returns 404 responses.

Examples

use actix_embed::Embed;
use actix_web::HttpResponse;
use rust_embed::RustEmbed;

#[derive(RustEmbed)]
#[folder = "testdata/"]
struct Assets;

let embed = Embed::new("/static", &Assets)
    .index_file("index.html")
    .fallback_handler(|_: &_| HttpResponse::BadRequest().body("not found"));

Note

It is necessary to add type annotation for the closure parameters like |_: &_| ....

See https://github.com/rust-lang/rust/issues/41078

Trait Implementations

impl<E, F> Debug for Embed<E, F>

where E: 'static + RustEmbed, F: FallbackHandler,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<E, F> HttpServiceFactory for Embed<E, F>

where E: 'static + RustEmbed, F: FallbackHandler,

fn register(self, config: &mut AppService)

impl<E, F> ServiceFactory<ServiceRequest> for Embed<E, F>

where E: 'static + RustEmbed, F: FallbackHandler,

type Response = ServiceResponse

Responses given by the created services.

type Error = Error

Errors produced by the created services.

type Config = ()

Service factory configuration.

type Service = EmbedService<E, F>

The kind of Service created by this factory.

type InitError = ()

Errors potentially raised while building a service.

type Future = Pin<Box<dyn Future<Output = Result<<Embed<E, F> as ServiceFactory<ServiceRequest>>::Service, <Embed<E, F> as ServiceFactory<ServiceRequest>>::InitError>>>>

The future of the Service instance.g

fn new_service(&self, _: ()) -> Self::Future

Create and return a new service asynchronously.