web-static-pack

Embed static resources (GUI, assets, images, styles, html) within executable. Serve with hyper or any server of your choice.

Usage scenario:

• Combines given directory tree into single, fast, binary-based single-file representation, called pack. Use simple CLI tool web-static-pack-packer to create a pack.
• Pack could be embedded into your application using include_bytes! single macro.
• Super-fast, zero-copy loader provides by-name access to files.
• Easy-to-use hyper_loader allows super-quick integration with hyper-based server.

Features:

• Super fast, low overhead
• 100% 'static access, zero data copy
• 100% pack-time calculated Content-Type, ETag (using sha3)
• 100% pack-time calculated gzip-compressed files
• Almost no external dependencies

Limitations:

• By default all files with guesses text/ content type are treated as utf-8
• Packs are not guaranteed to be portable across versions / architectures

Future goals:

• You tell me

Non-Goals:

• Directory listings
• automatic index.html resolving
• Uploads

Example:

1. Create a pack from cargo doc: bash $ cargo doc --no-deps $ cargo run ./target/doc/ docs.pack

2. Serve docs.pack from your web-application (see examples/docs) ```rust use anyhow::{Context, Error}; use hyper::{ service::{makeservicefn, servicefn}, Body, Request, Response, Server, }; use lazystatic::lazystatic; use log::LevelFilter; use simplelogger::SimpleLogger; use std::{convert::Infallible, includebytes, net::SocketAddr}; use webstaticpack::{hyperloader::Responder, loader::Loader};

[tokio::main]

async fn main() -> () { SimpleLogger::fromenv() .withlevel(LevelFilter::Info) .init() .unwrap(); main_result().await.unwrap() }

async fn service(request: Request) -> Result, Infallible> { lazystatic! { static ref PACK: &'static [u8] = includebytes!("docs.pack"); static ref LOADER: Loader = Loader::new(&PACK).unwrap(); static ref RESPONDER: Responder<'static> = Responder::new(&LOADER); }

Ok(RESPONDER.request_respond(&request))

}

async fn mainresult() -> Result<(), Error> { let address = SocketAddr::from(([0, 0, 0, 0], 8080)); let server = Server::bind(&address).serve(makeservicefn(|connection| async { Ok::<_, Infallible>(service_fn(service)) }));

log::info!("Server listening on {:?}", address);
Ok(server.await.context("server")?)

} ```