HTTP Server with KeepAlive about async-h1

[yoshuawuyts]

I wish we had async iterators tbh:

use async_h1::{server, Body};
use async_std::prelude::*;
use async_std::{net, task, io};

async fn main() -> throws {
    let listener = TcpListener::bind(("127.0.0.1", 8080)).await?;
    println!("listening on {}", listener.local_addr()?);

    par for stream.await? in listener.incoming() {
        for conn.await? in server::connect(stream) {
            let req = conn.decode().await?;
            println!("request: {:?}", req);
            let res = Response::new(Body::from("hello chashu"));
            conn.encode(res).await?;
        }
    }
}

[yoshuawuyts]

use async_h1::{server, Body};
use async_std::prelude::*;
use async_std::{net, task, io};

async fn main() -> throws {
    let listener = TcpListener::bind(("127.0.0.1", 8080)).await?;
    println!("listening on {}", listener.local_addr()?);

    par for stream.await? in listener.incoming() {
        for conn.await? in server::connect(stream) {
            println!("request: {:?}", req);
            let body = Body::from("hello chashu");
            let res = server::encode(Response::new(body));
            io::copy(res, conn).await?;
        }
    }
}

/// Proxy for an individual `TcpStream`, but respects the
/// header's `content-length` header.
struct Connection { headers }
impl AsyncRead for Connection {}
impl AsyncWrite for Connection {}

[yoshuawuyts]

A thing the original design didn't properly account for is that we can't "parse HTTP + send" in a single step. Being able to wrap it in SSL or compression streams is necessary.

[yoshuawuyts]

Alternative:

use async_h1::{server, Body};
use async_std::prelude::*;
use async_std::{net, task, io};

async fn main() -> throws {
    let listener = TcpListener::bind(("127.0.0.1", 8080)).await?;
    println!("listening on {}", listener.local_addr()?);

    par for stream.await? in listener.incoming() {
        for (req, writer).await? in server::connect(stream) {
            println!("request: {:?}", req);
            let body = Body::from("hello chashu");
            let res = server::encode(Response::new(body));
            io::copy(res, writer).await?;
        }
    }
}

[yoshuawuyts]

With @rylev:

use async_h1::{server, Body};
use async_std::prelude::*;
use async_std::{net, task, io};

async fn main() -> throws {
    let listener = TcpListener::bind(("127.0.0.1", 8080)).await?;
    println!("listening on {}", listener.local_addr()?);

    let mut incoming = listener.incoming();
    while let Some(tcp_connection) = incoming.next().await {
        let http_stream = server::connect(tcp_connection);

        while let Some((req, res)) = http_stream.next().await {
            println!("request: {:?}", req);
            let body = Body::from("hello chashu");
            res.send_stream(server::encode(Response::new(body))).await?;
        }
    }
}

use async_h1::{server, Body};
use async_std::prelude::*;
use async_std::{net, task, io};

async fn main() -> throws {
    let listener = TcpListener::bind(("127.0.0.1", 8080)).await?;
    println!("listening on {}", listener.local_addr()?);

    let mut incoming = listener.incoming();
    while let Some(tcp_connection) = incoming.next().await {
        server::connect(tcp_connection, |req| -> Result<Response> {
            println!("request: {:?}", req);
            let body = Body::from("hello chashu");
            Response::new(200, /* impl AsyncRead */)
        });
    }
}

[rylev]

Does this work?

use async_h1::{server, Body};
use async_std::prelude::*;
use async_std::{net, task, io};

async fn main() -> throws {
    let listener = TcpListener::bind(("127.0.0.1", 8080)).await?;
    println!("listening on {}", listener.local_addr()?);

    let mut incoming = listener.incoming();
    while let Some((tcp_reader, tcp_writer)) = incoming.next().await { // read and writer from tcp stream
        let http_stream = server::connect(tcp_reader);

        while let Some(req) = http_stream.next().await { // just each request as it comes. 
            println!("request: {:?}", req);
            let body = Body::from("hello chashu");
            tcp_writer.write_all(server::encode(Response::new(body))).await?;
        }
    }
}

[dignifiedquire]

following this logic, I would say it should be possible to do sth like this for the client

async fn main() -> throws {
    let tcp_stream = net::TcpStream::connect("127.0.0.1:8080").await?;
	let (tcp_reader, tcp_writer) = &mut (&tcp_stream, &tcp_stream);

    let http_stream = client::connect(tcp_reader);

    // lets make 10 requests, with the same connection
    for i in 0..10 {
		// Send a response
        let body = Body::from(format!("hello chashu {}", i));
        let mut req = client::encode(Request::new(body));
        tcp_writer.write_all(req).await?;

		// read the response
        let res = http_stream.next().await?;
        println!("Response {}: {:?}", i, res);
    }
}

[yoshuawuyts]

@dignifiedquire moved the conversation about clients over to #7; think it'd be nice to have a dedicated issue to track it there!

[rylev]

This is now in master with #11. Closing this in favor of more specific issues for remaining bugs and/or enhancements.