msg_transmitter

Function create_tcp_server

Source 
pub fn create_tcp_server<T>(addr: &str, server_name: &str) -> TCPMsgServer<T>
where
    T: DeserializeOwned + Serialize + Send + 'static + Clone,
Examples found in repository?
examples/simple_connection.rs (line 30)
29fn server() {
30    let server = create_tcp_server("127.0.0.1:6666", "server");
31    let server_task = server.start_server(0, |client_name, msg| {
32        println!("{}: {}", client_name, msg);
33        vec![(client_name, msg + 1)]
34    });
35    tokio::run(server_task);
36}
More examples
Hide additional examples
examples/master_and_slave.rs (line 55)
53fn master() {
54    use std::{thread, time};
55    let srv = create_tcp_server("127.0.0.1:7777", "master");
56    let master_task = srv.start_server(Message::Start(), |client_name, msg: Message| {
57        println!("master receive {:?} from {}", msg, client_name);
58        println!("sleep");
59        let ten_millis = time::Duration::from_millis(10000);
60        let now = time::Instant::now();
61        thread::sleep(ten_millis);
62        println!("awake");
63        vec![(client_name, Message::Stop())]
64    });
65    tokio::run(master_task);
66}
67
68fn manager() {
69    use futures::sync::mpsc;
70    use std::sync::{Arc, Mutex};
71    let future_task = future::ok(1).and_then(|_| {
72        let srv = create_tcp_server("127.0.0.1:6666", "management_server");
73        let clt = create_tcp_client("127.0.0.1:7777", "management_client");
74        let connections = srv.connections.clone();
75
76        let clt_task = clt.start_client(move |msg: Message| {
77            println!("manager receive {:?} from master", msg);
78            match msg {
79                Message::Stop() => {
80                    for (_, tx) in connections.lock().unwrap().iter_mut() {
81                        (*tx).try_send(Some(0)).unwrap();
82                    }
83                    std::process::exit(0);
84                }
85                _ =>{}
86            }
87            vec![msg]
88        });
89        tokio::spawn(clt_task);
90
91        let srv_task = srv.start_server(1, |client_name, msg: u32| {
92            println!("manager receive {} from {}", msg, client_name);
93            vec![(client_name, msg + 1)]
94        });
95        tokio::spawn(srv_task);
96        Ok(())
97    }).map_err(|e: std::io::Error| println!("{:?}", e));
98    tokio::run(future_task);
99}
examples/transmit_multiple_structs.rs (line 49)
48fn server() {
49    let server = create_tcp_server("127.0.0.1:6666", "server");
50    let server_task = server.start_server(Message::VecOfF32msg(VecOfF32 { vec: vec![] }), |client_name: String, msg: Message| {
51        println!("{}: {:?}", client_name, msg);
52        match msg {
53            Message::VecOfF32msg(vec_of_32) => {
54                if vec_of_32.vec.len() < 10 {
55                    vec![(client_name, Message::VecOfF32msg(vec_of_32))]
56                } else {
57                    vec![(client_name, Message::Endmsg(End))]
58                }
59            }
60            Message::Endmsg(_) => {
61                std::process::exit(0)
62            }
63        }
64    });
65    tokio::run(server_task);
66}