kig/line_server.rs

## line_server.rs
use {
    hyper::{
        service::{make_service_fn, service_fn},
        Body,
        Request,
        Response,
        Server,
    },
    std::net::SocketAddr,
    tokio::io::{BufReader, AsyncBufReadExt},
    std::sync::Arc,
    tokio::sync::RwLock,
};

struct Line {
    line: RwLock<String>,
}

async fn serve_req(_req: Request<Body>, buffer: Arc<Line>) -> Result<Response<Body>, hyper::Error> {
    Ok(Response::new(Body::from(format!("hello, {}!", buffer.line.read().await.to_string()))))
}

async fn run_server(addr: SocketAddr, buffer: Arc<Line>) {
    println!("Listening on http://{}", addr);
    let serve_future = Server::bind(&addr)
        .serve(make_service_fn(|_| {
            let buf = Arc::clone(&buffer);
            async {
                {
                    Ok::<_, hyper::Error>(service_fn(move |_req| {
                        serve_req(_req, Arc::clone(&buf))
                    }))
                }
            }
        }));

    if let Err(e) = serve_future.await {
        eprintln!("server error: {}", e);
    }
}

#[tokio::main]
async fn main() {
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));

    let mut reader = BufReader::new(tokio::io::stdin());
    let line = Arc::new(Line{line: RwLock::new(String::new()) });

    let server = run_server(addr, Arc::clone(&line));
    tokio::spawn(async move {
        server.await;
    });

    loop {
        {
            let mut s = String::new();
            match reader.read_line(&mut s).await {
                Ok(0) => {
                    println!("EOF");
                    break;
                }
                Ok(n) => {
                    println!("{} > {}", n, &s);
                    let mut tx_guard = line.line.write().await;
                    tx_guard.clear();
                    tx_guard.push_str(&s);
                }
                Err(error) => {
                    println!("error: {}", error);
                    break;
                }
            }
        }
    }
}
	use {
	hyper::{
	service::{make_service_fn, service_fn},
	Body,
	Request,
	Response,
	Server,
	},
	std::net::SocketAddr,
	tokio::io::{BufReader, AsyncBufReadExt},
	std::sync::Arc,
	tokio::sync::RwLock,
	};

	struct Line {
	line: RwLock<String>,
	}

	async fn serve_req(_req: Request<Body>, buffer: Arc<Line>) -> Result<Response<Body>, hyper::Error> {
	Ok(Response::new(Body::from(format!("hello, {}!", buffer.line.read().await.to_string()))))
	}

	async fn run_server(addr: SocketAddr, buffer: Arc<Line>) {
	println!("Listening on http://{}", addr);
	let serve_future = Server::bind(&addr)
	.serve(make_service_fn(\|_\| {
	let buf = Arc::clone(&buffer);
	async {
	{
	Ok::<_, hyper::Error>(service_fn(move \|_req\| {
	serve_req(_req, Arc::clone(&buf))
	}))
	}
	}
	}));

	if let Err(e) = serve_future.await {
	eprintln!("server error: {}", e);
	}
	}

	#[tokio::main]
	async fn main() {
	let addr = SocketAddr::from(([127, 0, 0, 1], 3000));

	let mut reader = BufReader::new(tokio::io::stdin());
	let line = Arc::new(Line{line: RwLock::new(String::new()) });

	let server = run_server(addr, Arc::clone(&line));
	tokio::spawn(async move {
	server.await;
	});

	loop {
	{
	let mut s = String::new();
	match reader.read_line(&mut s).await {
	Ok(0) => {
	println!("EOF");
	break;
	}
	Ok(n) => {
	println!("{} > {}", n, &s);
	let mut tx_guard = line.line.write().await;
	tx_guard.clear();
	tx_guard.push_str(&s);
	}
	Err(error) => {
	println!("error: {}", error);
	break;
	}
	}
	}
	}
	}