I have a trillium server that is backed by create-react-app.

In dev mode I would like to proxy directly to the server created by create-react-app, while in release mode I would like to serve the file that is embedded in the binary. Working sample of this can be found at https://github.com/prabirshrestha/objstor/pull/16.

Here is the main snippet:

use trillium::Handler;

#[cfg(not(debug_assertions))]
lazy_static_include::lazy_static_include_str! {
    INDEX_HTML => "../client/build/index.html",
}

#[cfg(debug_assertions)]
pub fn spa() -> impl Handler {
    use trillium_rustls::RustlsConnector;
    use trillium_tokio::TcpConnector;
    type Proxy = trillium_proxy::Proxy<RustlsConnector<TcpConnector>>;
    Proxy::new("http://localhost:3000")
}

#[cfg(not(debug_assertions))]
pub fn spa() -> impl Handler {
    use trillium_static_compiled::static_compiled;
    let handler = static_compiled!("../client/build").with_index_file("index.html");
    (handler, serve_index_file)
}

#[cfg(not(debug_assertions))]
async fn serve_index_file(conn: trillium::Conn) -> trillium::Conn {
    conn.with_header("content-type", "text/html; charset=UTF-8")
        .ok(INDEX_HTML.as_bytes())
}

I had to introduce lazy_static_include library and do a bit of custom code. It would be great if this was simplified as it is a common pattern for single page applications where there is usually just a single html file with most of the code logic in js. This could then be simplified as following.

#[cfg(not(debug_assertions))]
pub fn spa() -> impl Handler {
    trillium_static_compiled::static_compiled! 
        ("../client/build").with_index_file("index.html").with_fallback_file("index.html")
}

The other option would be to introduce static_compiled_file but then the file contents would be duplicated.

I've come into a situation where I need to call Tera::full_reload so I can reload templates in a development environment (versus respawning this application). I'm not sure if allowing for a From<Arc<Tera>> for TeraHandler would have helped here (because then I can control the instance of Tera being used (to a degree).

I know I opened this up as a PR versus going into discussions—mainly because it seemed simple enough. However, I can't get this imported into my project locally so I wasn't able to fully test this.

Currently, there is no way to access some methods of trillium::Conn from trillium_websocket::WebSocketConn, with the same issues as to require trillium::Conn's own .inner escape hatch. Alternatively, exposing said hatch of trillium::Conn would also be viable to provide such access to lower-level methods.

Describe the bug While using htmx.org, namely hx-post with <input type="hidden" name="_method" value="put"> in a form, I noticed that the request wasn't being translated into an PUT request on the server side.

To Reproduce Reproduction of this could work by copying one of the tests at trillium-rs/trillium#main/method-override/tests/tests.rs:L16-L29 but instead of checking the query string , putting the test body as the request body, like:

assert_ok!(post("/").with_request_body("_method=put").on(&app), "it was a PUT");

This way, it'll show that the use of only query string extraction wouldn't be enough. However, it looks like reading the body of the request will mutate the connection itself at https://docs.rs/trillium/latest/src/trillium/conn.rs.html#257-274. Perhaps an updated test will show otherwise.

Expected behavior Proper conversion of a POST request with a hint to the expected HTTP Verb.

Additional context I figure that the code of method-override is a bit older than the tests and perhaps led to this not being covered.

(Originally published at: https://jacky.wtf/2022/4/W1/W1YTNu6QaaLQ33o0zcbWFhRr)

Seems like trillium-static sends the file with correct response headers but never looks at the request header and always sends the full response body instead of a 304 Not Modified.

https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag#caching_of_unchanged_resources

The server compares the client's ETag (sent with If-None-Match) with the ETag for its current version of the resource, and if both values match (that is, the resource has not changed), the server sends back a 304 Not Modified status, without a body, which tells the client that the cached version of the response is still good to use (fresh).

I tend to use SocketAddr to define the listening address for Web applications. SocketAddr::ip gives back a type that implements ToString. This would make it a bit easier to pass in any sort of value.

Trillium looks really nice and I thought I'd give it a go for a small project. I was wondering if it's possible to run some code after the response is finished? I have a situation where I need to perform an operation that will affect the machine's ability to send a response, so this can only be started once the response has actually been sent.

It will be good if there are examples on https://github.com/mitsuhiko/systemfd and https://docs.rs/listenfd/0.3.3/listenfd/ or a first class create/optional feature on this.

Updates the requirements on base64 to permit the latest version.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

While working on Lighthouse, I wanted a way to 'build' route URLs for use elsewhere (like returning in a page or in my case, checking if it's referenced in a remote document as part of Webmention discovery). I attempted to do the following to build my paths—a change from manually writing in the URL, and it didn't work. It looks like TryFrom for RouteSpec is a thing, so I'm curious as to why it's been restricted to require a lifetime across the entire application.

    static URL_PATH_WEBMENTION_PREFIX: &str = "/endpoints/webmention";
Router::build(|mut router| {
    let path = format!("{}/:token", URL_PATH_WEBMENTION_PREFIX).as_str();

    // This _will_ fail, I did `path.as_str()` initially but of course, that's a short-lived reference.
    router.get(path, |conn: Conn| async move { conn.halt() })
})

(Originally posted at https://jacky.wtf/2022/4/nS/nSsFq7XHDUUOpXCc6ptwtfOx)

By default, tungstenite imposes a message size limit of about 67 megabytes. Unless I am missing something, these limits don't seem to be configurable in trillium. This isn't the end of the world, but I would like to be able to set more conservative limits as the defaults far exceed the largest messages permitted by my application.

When using trillium-error it takes &mut Conn.

Would need to add support for the following.

fn set_json(&mut self, response: &impl Serialize) -> Result<(), JsonValue>;

This is primarily used for content negotiation or special handling for api vs non api requests.

pub async fn not_found(conn: Conn) -> Conn {
    if conn.is_json_request() {
      conn.with_status(404).with_json(JsonError { message = "Not found", code = "NotFound" }).halt()
    } else {
       conn.with_status(404).with_body("Not Found").halt()
    }
    
}

I'm investigating utilizing io-uring runtimes for http servers. Trillium is my favorite so far. trillium-http has no runtime dependencies, so I think it won't be a big problem adding support for io-uring runtimes like monoio and glommio

Discussed in https://github.com/trillium-rs/trillium/discussions/212