spytial 0.2.0

Drop-in replacement for std::dbg! that opens an interactive diagram of Rust values (Spytial for Rust).
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use std::env;
use std::fs;
use std::io::{Read, Write};
use std::net::TcpListener;
use std::path::Path;
use std::process;

fn main() {
    let file_path = env::args()
        .nth(1)
        .unwrap_or_else(|| "/tmp/rust_viz_data.html".to_string());
    let port = env::var("SPYTIAL_PORT")
        .ok()
        .and_then(|raw| raw.parse::<u16>().ok())
        .unwrap_or(8080);

    if !Path::new(&file_path).exists() {
        eprintln!(
            "Visualization file does not exist: {}. Run a diagram example first.",
            file_path
        );
        process::exit(1);
    }

    let bind_addr = format!("0.0.0.0:{port}");
    let listener = TcpListener::bind(&bind_addr).unwrap_or_else(|error| {
        eprintln!("Failed to bind {}: {}", bind_addr, error);
        process::exit(1);
    });

    println!("Visualization server ready at http://localhost:{port}/rust_viz_data.html");
    println!("Health endpoint at http://localhost:{port}/health");

    for stream in listener.incoming() {
        match stream {
            Ok(mut stream) => handle_connection(&mut stream, &file_path),
            Err(error) => eprintln!("Connection error: {}", error),
        }
    }
}

fn handle_connection(stream: &mut std::net::TcpStream, file_path: &str) {
    let mut buffer = [0_u8; 4096];
    let bytes_read = match stream.read(&mut buffer) {
        Ok(0) => return,
        Ok(read) => read,
        Err(error) => {
            eprintln!("Failed to read request: {}", error);
            return;
        }
    };

    let request = String::from_utf8_lossy(&buffer[..bytes_read]);
    let mut parts = request
        .lines()
        .next()
        .unwrap_or_default()
        .split_whitespace();

    let method = parts.next().unwrap_or_default();
    let raw_path = parts.next().unwrap_or("/");
    let path = raw_path.split('?').next().unwrap_or(raw_path);

    if method != "GET" {
        write_response(
            stream,
            "405 Method Not Allowed",
            "text/plain; charset=utf-8",
            b"Method Not Allowed",
        );
        return;
    }

    match path {
        "/" => {
            let headers = "HTTP/1.1 302 Found\r\nLocation: /rust_viz_data.html\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
            if let Err(error) = stream.write_all(headers.as_bytes()) {
                eprintln!("Failed to write redirect response: {}", error);
            }
        }
        "/health" => write_response(stream, "200 OK", "text/plain; charset=utf-8", b"ok"),
        "/favicon.ico" => {
            write_response(stream, "204 No Content", "text/plain; charset=utf-8", b"")
        }
        "/rust_viz_data.html" => match fs::read(file_path) {
            Ok(contents) => write_response(stream, "200 OK", "text/html; charset=utf-8", &contents),
            Err(error) => {
                let body = format!("Failed to read visualization file: {}", error);
                write_response(
                    stream,
                    "500 Internal Server Error",
                    "text/plain; charset=utf-8",
                    body.as_bytes(),
                );
            }
        },
        _ => write_response(
            stream,
            "404 Not Found",
            "text/plain; charset=utf-8",
            b"Not Found",
        ),
    }
}

fn write_response(stream: &mut std::net::TcpStream, status: &str, content_type: &str, body: &[u8]) {
    let headers = format!(
        "HTTP/1.1 {status}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
        body.len()
    );

    if let Err(error) = stream.write_all(headers.as_bytes()) {
        eprintln!("Failed to write response headers: {}", error);
        return;
    }

    if let Err(error) = stream.write_all(body) {
        eprintln!("Failed to write response body: {}", error);
    }
}