extern crate asyncio;
use std::env;
use std::sync::{Arc, Mutex};
use std::io::{self, Read};
use std::fs::File;
use std::str::from_utf8;
use std::thread;
use std::time::Duration;
use asyncio::*;
use asyncio::ip::*;
use asyncio::socket_base::*;
static mut USE_LINUM : bool = false;
fn on_accept(sv: Arc<Mutex<TcpListener>>, res: io::Result<(TcpSocket, TcpEndpoint)>) {
if let Ok((soc, ep)) = res {
IoContext::spawn(sv.lock().unwrap().as_ctx(), move |coro| {
println!("connected from {}", ep);
loop {
let mut buf = [0; 256];
let len = soc.async_read_some(&mut buf, coro.wrap()).unwrap();
let filename = String::from(from_utf8(&buf[..len-2]).unwrap()).replace("/", "_");
println!("receive filename={}, len={}", filename, len);
if let Ok(mut fs) = File::open(filename) {
let mut str = String::new();
let mut num = 0;
if let Ok(_) = fs.read_to_string(&mut str) {
let lines: Vec<&str> =str.split('\n').collect();
for line in lines {
if unsafe { USE_LINUM } {
num += 1;
let num_buf = format!("{} ", num);
soc.async_write_some(num_buf.as_bytes(), coro.wrap()).unwrap();
}
if line.len() > 0 {
soc.async_write_some(line.as_bytes(), coro.wrap()).unwrap();
}
soc.async_write_some("\r\n".as_bytes(), coro.wrap()).unwrap();
thread::sleep(Duration::new(0, 100000000));
}
}
} else {
let msg = "Not found filename\r\n";
soc.async_write_some(msg.as_bytes(), coro.wrap()).unwrap();
}
}
});
}
start_server(sv)
}
fn start_server(sv: Arc<Mutex<TcpListener>>) {
sv.lock().unwrap().async_accept(wrap(on_accept, &sv))
}
fn main() {
let ctx = &IoContext::new().unwrap();
for arg in env::args().skip(1).into_iter() {
if arg == "-n" {
unsafe { USE_LINUM = true; }
}
}
let sv = TcpListener::new(ctx, Tcp::v4()).unwrap();
sv.set_option(ReuseAddr::new(true)).unwrap();
sv.bind(&TcpEndpoint::new(Tcp::v4(), 12345)).unwrap();
sv.listen().unwrap();
start_server(Arc::new(Mutex::new(sv)));
ctx.run();
}