Cargo build hangs - minimized, but not really rust-lang/rust#88862

Cargo.toml

[package]
name = "maybe"
version = "0.1.0"
edition = "2018"
resolver = "2"


[dependencies]
sqlx = { version = "0.5.7", default-features = false, features = [
    "runtime-tokio-native-tls",
    "offline",
    "postgres"
] }
tokio = { version = "1.11.0", features = ["sync"] }
tracing = "0.1.26"
thiserror = "1.0.29"
futures = "0.3.15"
anyhow = "1.0.44"
http = "0.2.4"
actix-web = "4.0.0-beta.9"

main.rs

#![allow(clippy::option_option)]
#![feature(bench_black_box)]

use thiserror::Error;

type Req = http::Request<Vec<u8>>;
type Response = http::Response<Vec<u8>>;
type BoxedFuture<'a, T> = std::pin::Pin<Box<dyn std::future::Future<Output = T> + Send + 'a>>;

/// A client that can do requests
trait OauthClient<'a>: Sync + Send + 'a {
    /// Error returned by the client
    type Error: std::error::Error + Send + Sync + 'static;
    /// Send a request
    fn req(
        &'a self,
        request: Req,
    ) -> BoxedFuture<'a, Result<Response, <Self as OauthClient>::Error>>;
}

struct DummyClient;

impl std::fmt::Debug for DummyClient {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str("DummyClient")
    }
}

impl std::fmt::Display for DummyClient {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str("DummyClient")
    }
}

impl Clone for DummyClient {
    fn clone(&self) -> Self { Self {} }
}

impl std::error::Error for DummyClient {}

impl<'a> OauthClient<'a> for DummyClient {
    type Error = DummyClient;

    fn req(&'a self, _: Req) -> BoxedFuture<'a, Result<Response, Self::Error>> {
        Box::pin(async move { Err(self.clone()) })
    }
}

impl<'a> ApiClient<'a> for DummyClient {
    type Error = DummyClient;

    fn req(&'a self, _: Req) -> BoxedFuture<'a, Result<Response, Self::Error>> {
        Box::pin(async move { Err(self.clone()) })
    }
}

enum DatabaseError {
    FooDbError,
}

impl std::fmt::Debug for DatabaseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str("DatabaseError")
    }
}

impl std::fmt::Display for DatabaseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str("DatabaseError")
    }
}

impl Clone for DatabaseError {
    fn clone(&self) -> Self { Self::FooDbError }
}

impl std::error::Error for DatabaseError {}

pub struct FooDb;


struct Token {
    id: i32,
}

struct NewToken {}

#[derive(Debug, thiserror::Error)]
enum GetTokenError<RE: std::error::Error + Send + Sync + 'static> {
    #[error(transparent)]
    DatabaseError(#[from] DatabaseError),
    #[error("token could not be validated, error: {0}")]
    RefreshTokenError(#[from] RefreshTokenError<RE>),
}

#[derive(thiserror::Error, Debug)]
enum RefreshTokenError<RE: std::error::Error + Send + Sync + 'static> {
    #[error("request when refreshing token failed")]
    RequestError(#[source] RE),
}

struct UserToken {}

// fns for user stuff on postgres
impl FooDb {
    /// Gets token, updating it if expired or almost expiring, removing invalid ones
    #[tracing::instrument(skip(self, http_client), err)]
    async fn get_token_with_scopes<'c, C>(
        &self,
        secret: Option<String>,
        http_client: &'c C,
    ) -> Result<Option<Token>, GetTokenError<<C as OauthClient<'c>>::Error>>
    where
        C: OauthClient<'c>,
    {
        // loop to do stuff
        loop {
            let token: Option<Token> = todo!();
            if let Some(secret) = secret.clone() {
                match token {
                    Some(token_) => {
                        let mut token: UserToken = todo!();
                        if token.expires_in().as_secs() <= 600 {
                            tracing::debug!("");
                            match token.refresh_token(http_client).await {
                                Ok(()) => {
                                    break self.upsert_token().await.map_err(Into::into).map(Some);
                                }
                                Err(RefreshTokenError::RequestError(error)) => {
                                    tracing::error!(refresh_error=?error , "");
                                    continue;
                                }
                            }
                        } else {
                            let _validated = match token.validate_token(http_client).await {
                                Ok(_) => {
                                    tracing::debug!("");
                                    break Ok(Some(token_));
                                }
                                Err(e @ RefreshTokenError::RequestError(..)) => {
                                    tracing::warn!(validation_error=?e, "");
                                }
                                Err(e) => break Err(e.into()),
                            };
                        }
                    }
                    None => break Ok(None),
                }
            } else {
                tracing::debug!("");
                break Ok(token);
            }
        }
    }

    // Removing this fixes the problem
    #[tracing::instrument(skip(self), err)]
    async fn upsert_token(&self) -> Result<Token, DatabaseError> {
        tracing::debug!("");

        let db: sqlx::PgPool = todo!();
        let mut conn = db.acquire().await.map_err(|e| {
            std::hint::black_box(e);
            DatabaseError::FooDbError
        })?;

        let query = sqlx::query_as::<sqlx::Postgres, (String, String)>("<query>");
        query
            .fetch_one(&mut conn)
            .await
            .map_err(|e| {
                std::hint::black_box(e);
                DatabaseError::FooDbError
            })
            .map(|(e, _)| Token {
                id: e.parse().unwrap(),
            })
    }
}

use actix_web::{web, App, HttpResponse, HttpServer};
use anyhow::Error;

fn main() -> Result<(), anyhow::Error> {

    let runtime = actix_web::rt::System::with_tokio_rt(|| {
        tokio::runtime::Builder::new_multi_thread()
            .thread_name("server-worker-pool")
            .enable_all()
            .build()
            .unwrap()
    });
    runtime.block_on(async { run().await })?;

    Ok(())
}

async fn run() -> Result<(), Error> {
    HttpServer::new(move || App::new().configure(configure))
        .bind((
            std::net::Ipv4Addr::from([0, 0, 0, 0]),
            std::env::var("WEB_APP_PORT")?.parse::<u16>()?,
        ))?
        .run()
        .await?;

    //monitor.abort();
    Ok(())
}

fn configure(cfg: &mut web::ServiceConfig) {
    cfg.service(web::scope("/rewards").service(rewards_update));
}

type SimpleClient = ApiFooClient<'static, DummyClient>;
trait ApiClient<'a>: Send + 'a {
    /// Error returned by the client
    type Error: std::error::Error + Send + Sync + 'static;
    /// Send a request
    fn req(&'a self, request: Req)
        -> BoxedFuture<'a, Result<Response, <Self as ApiClient>::Error>>;
}
struct ApiFooClient<'a, C>
where C: ApiClient<'a> {
    client: ApiBarClient<'a, C>,
}
struct ApiBarClient<'a, C>
where C: ApiClient<'a> {
    client: C,
    _pd: std::marker::PhantomData<&'a ()>, // TODO: Implement rate limiter...
}

impl<'a, C: ApiClient<'a> + Sync> ApiClient<'a> for ApiBarClient<'a, C> {
    type Error = <C as ApiClient<'a>>::Error;

    fn req(
        &'a self,
        request: Req,
    ) -> BoxedFuture<'a, Result<Response, <Self as ApiClient>::Error>> {
        ApiClient::req(&self.client, request)
    }
}

impl<'a, C: ApiClient<'a> + Sync> OauthClient<'a> for ApiBarClient<'a, C> {
    type Error = <C as ApiClient<'a>>::Error;

    fn req(
        &'a self,
        request: Req,
    ) -> BoxedFuture<'a, Result<Response, <Self as ApiClient>::Error>> {
        ApiClient::req(&self.client, request)
    }
}

impl<'a, C: ApiClient<'a> + Sync> ApiClient<'a> for ApiFooClient<'a, C> {
    type Error = <C as ApiClient<'a>>::Error;

    fn req(
        &'a self,
        request: Req,
    ) -> BoxedFuture<'a, Result<Response, <Self as ApiClient>::Error>> {
        ApiClient::req(&self.client, request)
    }
}

impl<'a, C: ApiClient<'a> + Sync> OauthClient<'a> for ApiFooClient<'a, C> {
    type Error = <C as ApiClient<'a>>::Error;

    fn req(
        &'a self,
        request: Req,
    ) -> BoxedFuture<'a, Result<Response, <Self as ApiClient>::Error>> {
        ApiClient::req(&self.client, request)
    }
}

#[actix_web::post("update")]
async fn rewards_update(
    database: web::Data<FooDb>,
    client: web::Data<SimpleClient>,
) -> Result<HttpResponse, Box<dyn std::error::Error + 'static>> {
    let token = database
        .get_token_with_scopes(None, client.as_ref())
        .await?
        .ok_or_else(|| std::io::Error::from(std::io::ErrorKind::NotFound))?;
    //std::hint::black_box(token);
    todo!();
}

impl UserToken {
    fn expires_in(&self) -> std::time::Duration { todo!() }

    async fn refresh_token<'a, C: OauthClient<'a>>(
        &self,
        http_client: &'a C,
    ) -> Result<(), RefreshTokenError<<C as OauthClient<'a>>::Error>> {
        todo!()
    }

    async fn validate_token<'a, C: OauthClient<'a>>(
        &self,
        http_client: &'a C,
    ) -> Result<String, RefreshTokenError<<C as OauthClient<'a>>::Error>> {
        todo!()
    }
}

rustc-after.svg

rustc-before.svg

summarize.csv