Working with a non static executor?

[TuTiuTe]

Hello, I am trying to use the crate smol-axum, but I've encountered a compile error (documented better here notgull/smol-axum#3)

TL;DR + additional info: this change 58e0e7d seems to be breaking smol-hyper's implementation of Executor, which implements it over async_executor's executors. It goes like this:

impl<'a, E: AsRef<async_executor::Executor<'a>> + ?Sized, Fut: Future + Send + 'a> hyper::rt::Executor<Fut>
    for SmolExecutor<E>
where
    Fut::Output: Send + 'a,
{
    #[inline]
    fn execute(&self, fut: Fut) {
        self.get_ref().as_ref().spawn(fut).detach();
    }
}

Where SmolExecutor is a wrapper to a type that derefs to an executor from smol crate

The issue lies when passing this smol executor to an http2 builder and calling serve (try to compile smol-axum's hello example after running cargo update), the reference in SmolExecutor goes out of scope but the SmolExecutor is still in use

As the author of both crates has stated that they won't be very active now, I wanted to help out and fix this myself, however I lack the technical skill, and trying to get to understand this project is a hard task.

I struggle to find what's so different after the commit that made this no longer work, I'd guess the fact there is an added E generic trait parameter to a lot of types is holding hostage the SmolExecutor but not the underlying executor which slips out of scope

Reading what I can find about hyper's executor trait, all the examples operate over a globally defined executor, with static lifetimes, so there's never an issue

So, my question is: Is the implementation of an Executor over a non static lifetime possible, or was it an oversight to begin with?
If it's possible, an example would be much appreciated. If it's not, what could be done to circumvent the issue, aside from the worst case scenario of "make the executor global" which defeats the whole purpose of using smol imo

[seanmonstar]

Interesting. I don't think I every really considered a non-static executor. The current design does require that the executor be able to spawn itself, otherwise there shouldn't necessarily be a problem.

[TuTiuTe]

I'll try to make a simple example this week and I'll get back to you if hyper is the roadblock. Rn I'm getting more familiar with async rust

[TuTiuTe]

@seanmonstar I've tried to make use of a non static executor, taking example of how the smol crate does it (mostly the prior mentioned smol-axum that does not compile with latest hyper) and the http2 example from here, and got a compiling snippet supposed to spawn an http2 server, but it crashes on any incoming connections. Curling it gives Received HTTP/0.9 when not allowed and my program's output is Error serving connection: http2 error

This is the code

use smol::Async;
use std::borrow::Borrow;
use std::ops::Deref;

use smol::Executor;
use smol_hyper::rt::FuturesIo;
use smol_hyper::rt::SmolTimer;

use std::net::TcpListener;
use std::sync::Arc;

use http_body_util::Full;
use hyper::body::Bytes;
use hyper::service::service_fn;
use hyper::{Request, Response};
use std::convert::Infallible;

use smol_hyper::rt::SmolExecutor;

#[derive(Clone)]
struct LocalExecutor<'ex, T: Deref<Target = smol::Executor<'ex>>>(T);

impl<'ex, T: Deref<Target = smol::Executor<'ex>>, Fut: Send + Future + 'ex> hyper::rt::Executor<Fut>
    for LocalExecutor<'ex, T>
where
    <Fut as std::future::Future>::Output: std::marker::Send + 'ex,
{
    fn execute(&self, fut: Fut) {
        self.0.deref().spawn(fut).detach();
        // eprintln!("not yet implemented");
        // todo!()
    }
}

async fn hello(_: Request<hyper::body::Incoming>) -> Result<Response<Full<Bytes>>, Infallible> {
    Ok(Response::new(Full::new(Bytes::from("Hello, World!"))))
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let ex = &Arc::new(Executor::new());

    smol::block_on(ex.run(async {
        let listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 8000))?;

        loop {
            let (stream, _) = listener.accept().await?;

            ex.spawn({
                let ex = ex.clone();
                async {
                    // if let Err(e) = hyper::server::conn::http1::Builder::new()
                    // if let Err(e) = hyper::server::conn::http2::Builder::new(SmolExecutor::new(ex))
                    if let Err(e) = hyper::server::conn::http2::Builder::new(LocalExecutor(ex))
                        .timer(SmolTimer::new())
                        .serve_connection(FuturesIo::new(stream), service_fn(hello))
                        .await
                    {
                        eprintln!("Error serving connection: {e}");
                    }
                    Ok::<(), hyper::Error>(())
                }
            })
            .detach();
        }
    }))
}

There are some commented lines in main, in loop:

• first one is just http1, which works.
• Second one is http2 + smol_hyper's smol::Executor wrapper implementation, which does not work.
• Third one is mine + http2, which does not work.

The thing is that commenting the line self.0.deref().spawn(fut).detach(); and uncommenting the two after, we get the same error message and no "not yet implemented" is printed, which makes me believe that the error does not even reach the code in my executor. Anyway, lmk what you think

Cargo.toml file

[package]
name = "smol-and-hyper"
version = "0.1.0"
edition = "2024"

[dependencies]
http-body-util = "0.1.3"
hyper = { version = "1.8.1", features = ["http1", "http2", "server"] }
smol = "2.0.2"
smol-hyper = "0.1.1"

[seanmonstar]

Sounds like your having curl send an HTTP/1 request and in your code you have an HTTP/2 server. Try using curl --http2-prior-knowledge.

[TuTiuTe]

Lovely, seems to be working!
I'll try again with hyper_util as this was the main issue in smol_axum, and if I'm able to make it work I'll mark this as the solution

[TuTiuTe]

After a bunch of back and forth with the non compiling smol-axum code and my implementation, I've figured out that smol-axum not compiling after updating hyper is not caused by hyper, rather the update has also upped the rust version, and the borrow checker forbids the code. I am struggling quite a bit with properly diagnosing the error as I'm unfamiliar with async rust, but it's been cool to learn and to be able to implement a workaround for my project even though I have still no clue how to help with smol-axum.

Their implementation is very generic and involves sending a reference inside the executor, and I think hyper 1.8.0 broke that support