gotham-rs/gotham

Hi all, I'm struggling using the StateMiddleware when I use async fn handler functions.

Here's what works using a regular, synchronous handler function:

#[macro_use]
extern crate gotham_derive;

use gotham::middleware::state::StateMiddleware;
use gotham::pipeline::single_middleware;
use gotham::pipeline::single::single_pipeline;
use gotham::router::builder::*;
use gotham::router::Router;
use gotham::state::{FromState, State};
use std::sync::{Arc, Mutex};
use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
use std::sync::mpsc::SyncSender;


#[derive(Debug)]
pub struct Record {
    field: String,
}
impl Record {
    pub fn new(field: String) -> Self {
        Self {
            field: field
        }
    }
}

#[derive(Clone, StateData)]
pub struct SenderState {
    inner: Arc<Mutex<SyncSender<Record>>>,
}
impl SenderState {
    pub fn new(sender: SyncSender<Record>) -> Self {
        Self {
            inner: Arc::new(Mutex::new(sender)),
        }
    }

    fn send(&self, record: Record) {
        let tx = &*(self.inner.lock().unwrap());
        tx.send(record).unwrap();
    }
}

fn index(state: State) -> (State, String) {
    let wc = SenderState::borrow_from(&state);
    wc.send(Record::new());
    (state, String::from(""))
}

pub fn router(sender_state: SenderState) -> Router {
    let middleware = StateMiddleware::new(sender_state);
    let pipeline = single_middleware(middleware);
    let (chain, pipelines) = single_pipeline(pipeline);
    build_router(chain, pipelines, |route| {
        route.post("/").to(index);
    })
}

#[tokio::main]
pub async fn main() {
    let (tx, rx): (SyncSender<Record>, Receiver<Record>) = sync_channel(10);
    let wc = SenderState::new(tx);
    gotham::start(addr, router(wc));
}

Now, as far as I understand and can tell, doing so is a bad idea, since I'm blocking the event loop.

So, I figured, I'll make the handler function async:

#[macro_use]
extern crate gotham_derive;

use gotham::middleware::state::StateMiddleware;
use gotham::pipeline::single_middleware;
use gotham::pipeline::single::single_pipeline;
use gotham::router::builder::*;
use gotham::router::Router;
use gotham::state::{FromState, State};
use futures::lock::Mutex;
use std::sync::Arc;
use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
use std::sync::mpsc::SyncSender;
use gotham::hyper::{Body, Response, StatusCode};

#[derive(Debug)]
pub struct Record {
    field: String,
}
impl Record {
    pub fn new(field: String) -> Self {
        Self {
            field: field
        }
    }
}

#[derive(Clone, StateData)]
pub struct SenderState {
    inner: Arc<Mutex<SyncSender<Record>>>,
}
impl SenderState {
    pub fn new(sender: SyncSender<Record>) -> Self {
        Self {
            inner: Arc::new(Mutex::new(sender)),
        }
    }

    async fn send(self, record: Record) {
        self.inner.lock().await.send(record).await.unwrap();
    }
}

async fn index(state: State) -> HandlerResult {
    let wc = SenderState::borrow_from(&state);
    wc.send(Record::new()).await;
    Ok((
        state,
        Response::builder()
            .status(StatusCode::ACCEPTED)
            .body(Body::empty())
            .unwrap(),
    ))
}

pub fn router(sender_state: SenderState) -> Router {
    let middleware = StateMiddleware::new(sender_state);
    let pipeline = single_middleware(middleware);
    let (chain, pipelines) = single_pipeline(pipeline);
    build_router(chain, pipelines, |route| {
        route.post("/").to_async(index);
    })
}

#[tokio::main]
pub async fn main() {
    let (tx, rx): (SyncSender<Record>, Receiver<Record>) = sync_channel(10);
    let wc = SenderState::new(tx);
    gotham::start(addr, router(wc));
}