oxidux 0.4.0

Reverse proxy and process manager for web app development.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use futures::StreamExt;
use hyper::{Body, Request, Response, StatusCode};

use crate::app::App;

pub async fn handle_request(
    request: Request<Body>,
    app: App,
) -> color_eyre::Result<Response<Body>> {
    let action = request.uri().path().split('/').nth(2);

    match action {
        Some("status") => status_response(app).await,
        Some("logstream") => logstream_response(app).await,
        _ => not_found_response(),
    }
}

pub fn is_meta_request<T>(request: &Request<T>) -> bool {
    request.uri().path().starts_with("/__oxidux__/")
}

async fn status_response(app: App) -> color_eyre::Result<Response<Body>> {
    let mut status = "".to_string();

    for process in app.processes {
        status.push_str(&format!(
            "{}: {}\n",
            process.name().await,
            process
                .pid()
                .await
                .map(|p| p.to_string())
                .unwrap_or_else(|| "Stopped".to_string())
        ));
    }

    Ok(Response::new(Body::from(status)))
}

fn not_found_response() -> color_eyre::Result<Response<Body>> {
    Ok(Response::builder()
        .status(StatusCode::NOT_FOUND)
        .body(Body::from("Not Found"))?)
}

async fn logstream_response(app: App) -> color_eyre::Result<Response<Body>> {
    let output = app
        .output_stream()
        .await
        .then(|(process, line)| async move {
            Ok::<_, eyre::Error>(format!("data: {}: {}\n\n", process.name().await, line))
        });

    Ok(Response::builder()
        .header("Content-Type", "text/event-stream")
        .header("Cache-Control", "no-cache")
        .body(Body::wrap_stream(output))?)
}