feat: add message-io

__network/message_io/src/client.rs

@@ -0,0 +1,46 @@
+use super::common::{Message};
+
+use message_io::events::{EventQueue};
+use message_io::network::{Network, NetEvent, Transport};
+
+use std::time::{Duration};
+
+enum Event {
+    Network(NetEvent<Message>),
+    Greet,
+}
+
+pub fn run(name: &str) {
+    let mut event_queue = EventQueue::new();
+
+    let network_sender = event_queue.sender().clone();
+    let mut network = Network::new(move |net_event| network_sender.send(Event::Network(net_event)));
+
+    let server_addr = "127.0.0.1:3000";
+    if let Ok(server_id) = network.connect(Transport::Tcp, server_addr) {
+        success!("Connect to server by TCP at {}", server_addr);
+        event_queue.sender().send(Event::Greet);
+
+        loop {
+            match event_queue.receive() {
+                Event::Greet => {
+                    network.send(server_id, Message::Greetings(format!("Hi, I am {}", name)));
+                    event_queue.sender().send_with_timer(Event::Greet, Duration::from_secs(1));
+                }
+                Event::Network(net_event) => match net_event {
+                    NetEvent::Message(_, message) => match message {
+                        Message::Greetings(text) => information!("Server says: {}", text),
+                    },
+                    NetEvent::AddedEndpoint(_) => unreachable!(),
+                    NetEvent::RemovedEndpoint(_) => {
+                        information!("Server is disconnected");
+                        return
+                    }
+                    NetEvent::DeserializationError(_) => (),
+                },
+            }
+        }
+    } else {
+        failure!("Can not connect to the server by TCP to {}", server_addr);
+    }
+}

__network/message_io/src/common.rs

@@ -0,0 +1,6 @@
+use serde::{Serialize, Deserialize};
+
+#[derive(Serialize, Deserialize)]
+pub enum Message {
+    Greetings(String),
+}

__network/message_io/src/main.rs

@@ -0,0 +1,17 @@
+#[macro_use] extern crate rust_util;
+
+mod common;
+mod client;
+mod server;
+
+pub fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    match args.get(1).unwrap_or(&String::new()).as_ref() {
+        "client" => match args.get(2) {
+            Some(name) => client::run(name),
+            None => failure!("The client needs a 'name'"),
+        },
+        "server" => server::run(),
+        _ => information!("Usage: basic client | server"),
+    }
+}

__network/message_io/src/server.rs

@@ -0,0 +1,69 @@
+use super::common::{Message};
+
+use message_io::events::{EventQueue};
+use message_io::network::{Network, NetEvent, Endpoint, Transport};
+
+use std::collections::{HashMap};
+
+struct ClientInfo {
+    count: usize,
+}
+
+enum Event {
+    Network(NetEvent<Message>),
+}
+
+pub fn run() {
+    let mut event_queue = EventQueue::new();
+
+    let network_sender = event_queue.sender().clone();
+    let mut network = Network::new(move |net_event| {
+        network_sender.send(Event::Network(net_event))
+    });
+
+    let mut clients: HashMap<Endpoint, ClientInfo> = HashMap::new();
+
+    let listen_addr = "127.0.0.1:3000";
+    match network.listen(Transport::Tcp, listen_addr) {
+        Ok(_) => success!("TCP Server running at {}", listen_addr),
+        Err(_) => return failure!("Can not listening at {}", listen_addr),
+    }
+
+    loop {
+        match event_queue.receive() {
+            Event::Network(net_event) => match net_event {
+                NetEvent::Message(endpoint, message) => match message {
+                    Message::Greetings(text) => {
+                        let mut client_info = clients.get_mut(&endpoint).unwrap();
+                        client_info.count += 1;
+                        information!(
+                            "Client ({}) says '{}' {} times",
+                            endpoint.addr(),
+                            text,
+                            client_info.count
+                        );
+                        let msg = format!("Hi, I hear you for {} time", client_info.count);
+                        network.send(endpoint, Message::Greetings(msg));
+                    }
+                },
+                NetEvent::AddedEndpoint(endpoint) => {
+                    clients.insert(endpoint, ClientInfo { count: 0 });
+                    information!(
+                        "Client ({}) connected (total clients: {})",
+                        endpoint.addr(),
+                        clients.len()
+                    );
+                }
+                NetEvent::RemovedEndpoint(endpoint) => {
+                    clients.remove(&endpoint).unwrap();
+                    information!(
+                        "Client ({}) disconnected (total clients: {})",
+                        endpoint.addr(),
+                        clients.len()
+                    );
+                }
+                NetEvent::DeserializationError(_) => (),
+            },
+        }
+    }
+}