Listen on windows named pipe

[nicolaspernoud]

Summary

Hello,

On unix, there is a way to open a web server on an unix socket (https://github.com/tokio-rs/axum/tree/main/examples/unix-domain-socket).
UDS are supported on windows, but not yet with tokio.

Is there a way to use a named pipe in the meantime ? Would that even make sense ? (I do not know really how named pipes work).

Thanks,

axum version

0.8.1

[mladedav]

I'm not sure about windows internals, but if there is a similar concept, you just need to implement Listener on a strict that accepts new connections it similarly to what we do for UDS.

You can look up the trait and feel free to ask follow-up questions if something isn't clear there.

[nicolaspernoud]

I managed to get it working with raw hyper by doing :
Using (https://github.com/fussybeaver/hyper-named-pipe for client),

use std::error::Error;

use axum::{routing::get, Router};
use http_body_util::{BodyExt, Full};
use hyper::body::Incoming;
use hyper::{body::Bytes, Request};
use hyper_named_pipe::{NamedPipeConnector, NAMED_PIPE_SCHEME};
use hyper_util::{
    client::legacy::Client,
    rt::{TokioExecutor, TokioIo},
};
use tokio::net::windows::named_pipe::ServerOptions;
use tower_service::Service;

#[tokio::test]
async fn test_axum() -> Result<(), Box<dyn Error + Send + Sync>> {
    const PIPE_NAME: &str = r"\\.\pipe\named-pipe-test-server";

    let mut server = ServerOptions::new()
        .first_pipe_instance(true)
        .create(PIPE_NAME)?;

    // Spawn the server loop.
    let _server = tokio::spawn(async move {
        loop {
            server.connect().await?;
            let connected_client = server;

            server = ServerOptions::new().create(PIPE_NAME)?;

            let io = TokioIo::new(connected_client);

            let app = Router::new()
                .route("/", get(handler))
                .route("/test", get(handler2));

            let hyper_service = hyper::service::service_fn(move |request: Request<Incoming>| {
                app.clone().call(request)
            });

            let _client = tokio::spawn(async move {
                hyper::server::conn::http1::Builder::new()
                    .serve_connection(io, hyper_service)
                    .await
                    .expect("Failed to wrap named pipe server with hyper HTTP interface")
            });
        }
        Ok::<_, std::io::Error>(())
    });

    let builder = Client::builder(TokioExecutor::new());
    let client: Client<NamedPipeConnector, Full<Bytes>> = builder.build(NamedPipeConnector);

    let host = hex::encode(PIPE_NAME);
    let uri_str = format!("{}://{}", NAMED_PIPE_SCHEME, host);
    let url = uri_str.parse().expect("Failed to parse uri");

    let response = client
        .get(url)
        .await
        .expect("Failed to get URL using hyper client");

    let body = response.collect().await.unwrap().to_bytes();
    let body = String::from_utf8(body.to_vec()).unwrap();
    assert_eq!(body, "Hello, World!");

    let client2: Client<NamedPipeConnector, Full<Bytes>> = builder.build(NamedPipeConnector);
    let uri_str = format!("{}://{}/test", NAMED_PIPE_SCHEME, host);
    let url = uri_str.parse().expect("Failed to parse uri");
    let response = client2
        .get(url)
        .await
        .expect("Failed to get URL using hyper client");

    let body = response.collect().await.unwrap().to_bytes();
    let body = String::from_utf8(body.to_vec()).unwrap();
    assert_eq!(body, "Hello, Test!");

    Ok(())
}

async fn handler() -> &'static str {
    "Hello, World!"
}

async fn handler2() -> &'static str {
    "Hello, Test!"
}

I guess that we could also do the following...

Given that we can create a named pipe server with :

let pipe_name = r"\\.\pipe\named-pipe-test-server";
    let server: NamedPipeServer = ServerOptions::new()
        .first_pipe_instance(true)
        .create(pipe_name)?;

and given that we can get an io from this server with :

        server
            .connect()
            .await
            .expect("Failed to connect to named pipe");

        let io = TokioIo::new(server);

I guess that we could wrap that io in a struct that implement listener, with he pipe name as Addr ?