fixed.rs

use lunatic::net::{TcpListener, TcpStream};
use lunatic::process::{self, Process};
use lunatic::Mailbox;
use std::io::{BufRead, BufReader, Write};
use std::net::SocketAddr;

#[derive(serde::Serialize, serde::Deserialize)]
struct Request {
    from: Process<String>,
    data: String,
}

#[derive(serde::Serialize, serde::Deserialize)]
struct StartContext {
    socket: TcpStream,
    addr: SocketAddr,
    internal: Process<Request>,
}

fn InternalServer(mb: Mailbox<Request>) {
    while let msg = mb.receive() {
        msg.from.send(("ReSP:".to_string() + &msg.data).clone());
    }
}

fn ClientProcess(mut ctx: StartContext, mb: Mailbox<String>) {
    println!("before");

    let mut reader = BufReader::new(ctx.socket.clone());
    let (this, mb) = process::this(mb);

    println!("client");

    loop {
        let mut data = String::new();
        reader.read_line(&mut data).unwrap();

        println!("in: {}", data);

        ctx.internal.send(Request {
            from: this.clone(),
            data,
        });

        let resp = mb.receive();
        println!("out: {}", resp);
        ctx.socket.write(resp.as_bytes()).unwrap();
    }
}

fn main() {
    let internalServer = process::spawn(InternalServer).unwrap();
    let listener = TcpListener::bind("0.0.0.0:1337").unwrap();

    while let Ok((stream, addr)) = listener.accept() {
        process::spawn_with(
            StartContext {
                socket: stream, /*.clone()*/
                addr,
                internal: internalServer.clone(),
            },
            ClientProcess,
        );
    }
}