Struct UnixListener

Source

pub struct UnixListener { /* private fields */ }

Implementations§

Source §

impl UnixListener

Source

pub fn bind<P: AsRef<Path>>(path: P, context: &MainContext) -> Result<Self>

Examples found in repository ?

examples/named.rs (line 76)

57fn main() {
58    futures_glib::init();
59
60    let path = "/tmp/named.socket";
61
62    let cx = MainContext::default(|cx| cx.clone());
63    let lp = MainLoop::new(None);
64    let ex = Executor::new();
65    ex.attach(&cx);
66
67    let remote = ex.remote();
68
69    let (sender, receiver) = channel();
70
71    let inner_path = path.clone();
72    thread::spawn(move || {
73        remote.spawn(move |ex: Executor| {
74            let cx = MainContext::default(|cx| cx.clone());
75            remove_file(inner_path).ok();
76            let listener = UnixListener::bind(inner_path, &cx).unwrap();
77
78            sender.send(true);
79
80            let inner_ex = ex.clone();
81            let incoming = listener.incoming()
82                .for_each(move |(stream, _addr)| {
83                    let frame = stream.framed(LineCodec);
84
85                    inner_ex.spawn(frame.for_each(|value| {
86                        println!("Received: {:?}", value);
87                        Ok(())
88                    }).map_err(|_| ()));
89                    Ok(())
90                })
91            .map_err(|_| ());
92
93            ex.spawn(incoming);
94            Ok(())
95        });
96    });
97
98    let send = receiver.then(move |_| {
99            UnixStream::connect(path, &cx)
100        })
101        .and_then(|stream2| {
102            Ok(stream2.framed(LineCodec))
103        })
104        .and_then(|frame2| {
105            frame2.send("Hello".to_string())
106        });
107    // TODO: send too early? Should accept before?
108    ex.spawn(send.map(|_| ())
109             .map_err(|_| ()));
110
111    lp.run();
112    ex.destroy();
113}

More examples

Hide additional examples

examples/named-splitted.rs (line 67)

56fn main() {
57    futures_glib::init();
58
59    let path = "/tmp/named.socket";
60
61    let cx = MainContext::default(|cx| cx.clone());
62    let lp = MainLoop::new(None);
63    let ex = Executor::new();
64    ex.attach(&cx);
65
66    remove_file(path).ok();
67    let listener = UnixListener::bind(path, &cx).unwrap();
68
69    let remote = ex.remote();
70
71    let inner_ex = ex.clone();
72    let incoming = listener.incoming()
73        .for_each(move |(stream, _addr)| {
74            let (reader, writer) = stream.split();
75            let mut framed_writer = FramedWrite::new(writer, LineCodec);
76            let framed_reader = FramedRead::new(reader, LineCodec);
77
78            inner_ex.spawn(framed_reader.and_then(|value| {
79                println!("Received: {:?}", value);
80                Ok(())
81            }).for_each(move |_| {
82                if let Ok(AsyncSink::Ready) = framed_writer.start_send("Received".to_string()) {
83                    framed_writer.poll_complete().unwrap();
84                }
85                Ok(())
86            }).map_err(|_| ()));
87            Ok(())
88        })
89        .map_err(|_| ());
90
91    ex.spawn(incoming);
92
93    thread::spawn(move || {
94        remote.spawn(move |ex: Executor| {
95            let connection = UnixStream::connect(path, &cx);
96            let exe = ex.clone();
97            let future = connection.and_then(move |stream| {
98                let (reader, writer) = stream.split();
99                let framed_writer = FramedWrite::new(writer, LineCodec);
100                let framed_reader = FramedRead::new(reader, LineCodec);
101                exe.spawn(framed_reader.for_each(|value| {
102                    println!("Thread received: {:?}", value);
103                    Ok(())
104                }).map_err(|_| ()));
105                exe.spawn(framed_writer.send("Hello".to_string())
106                         .map(|_| ())
107                         .map_err(|_| ()));
108                Ok(())
109            })
110                .map_err(|_| ());
111            ex.spawn(future);
112            Ok(())
113        });
114    });
115
116    lp.run();
117    ex.destroy();
118}

Source

pub fn bind_abstract(name: &[u8], context: &MainContext) -> Result<Self>

Examples found in repository ?

examples/abstract.rs (line 65)

55fn main() {
56    futures_glib::init();
57
58    let path = b"named-socket";
59
60    let cx = MainContext::default(|cx| cx.clone());
61    let lp = MainLoop::new(None);
62    let ex = Executor::new();
63    ex.attach(&cx);
64
65    let listener = UnixListener::bind_abstract(path, &cx).unwrap();
66
67    let remote = ex.remote();
68
69    let inner_ex = ex.clone();
70    let incoming = listener.incoming()
71        .for_each(move |(stream, _addr)| {
72            let (reader, writer) = stream.split();
73            let mut framed_writer = FramedWrite::new(writer, LineCodec);
74            let framed_reader = FramedRead::new(reader, LineCodec);
75
76            inner_ex.spawn(framed_reader.and_then(|value| {
77                println!("Received: {:?}", value);
78                Ok(())
79            }).for_each(move |_| {
80                if let Ok(AsyncSink::Ready) = framed_writer.start_send("Received".to_string()) {
81                    framed_writer.poll_complete().unwrap();
82                }
83                Ok(())
84            }).map_err(|_| ()));
85            Ok(())
86        })
87        .map_err(|_| ());
88
89    ex.spawn(incoming);
90
91    thread::spawn(move || {
92        remote.spawn(move |ex: Executor| {
93            let connection = UnixStream::connect_abstract(path, &cx).unwrap();
94            let exe = ex.clone();
95            let future = connection.and_then(move |stream| {
96                let (reader, writer) = stream.split();
97                let framed_writer = FramedWrite::new(writer, LineCodec);
98                let framed_reader = FramedRead::new(reader, LineCodec);
99                exe.spawn(framed_reader.for_each(|value| {
100                    println!("Thread received: {:?}", value);
101                    Ok(())
102                }).map_err(|_| ()));
103                exe.spawn(framed_writer.send("Hello".to_string())
104                         .map(|_| ())
105                         .map_err(|_| ()));
106                Ok(())
107            })
108                .map_err(|_| ());
109            ex.spawn(future);
110            Ok(())
111        });
112    });
113
114    lp.run();
115    ex.destroy();
116}

Source

pub fn from_fd(fd: RawFd, context: &MainContext) -> Self

Source

pub fn accept(&mut self) -> Result<(UnixStream, SocketAddr)>

Source

pub fn incoming(self) -> Incoming

Examples found in repository ?

examples/named.rs (line 81)

57fn main() {
58    futures_glib::init();
59
60    let path = "/tmp/named.socket";
61
62    let cx = MainContext::default(|cx| cx.clone());
63    let lp = MainLoop::new(None);
64    let ex = Executor::new();
65    ex.attach(&cx);
66
67    let remote = ex.remote();
68
69    let (sender, receiver) = channel();
70
71    let inner_path = path.clone();
72    thread::spawn(move || {
73        remote.spawn(move |ex: Executor| {
74            let cx = MainContext::default(|cx| cx.clone());
75            remove_file(inner_path).ok();
76            let listener = UnixListener::bind(inner_path, &cx).unwrap();
77
78            sender.send(true);
79
80            let inner_ex = ex.clone();
81            let incoming = listener.incoming()
82                .for_each(move |(stream, _addr)| {
83                    let frame = stream.framed(LineCodec);
84
85                    inner_ex.spawn(frame.for_each(|value| {
86                        println!("Received: {:?}", value);
87                        Ok(())
88                    }).map_err(|_| ()));
89                    Ok(())
90                })
91            .map_err(|_| ());
92
93            ex.spawn(incoming);
94            Ok(())
95        });
96    });
97
98    let send = receiver.then(move |_| {
99            UnixStream::connect(path, &cx)
100        })
101        .and_then(|stream2| {
102            Ok(stream2.framed(LineCodec))
103        })
104        .and_then(|frame2| {
105            frame2.send("Hello".to_string())
106        });
107    // TODO: send too early? Should accept before?
108    ex.spawn(send.map(|_| ())
109             .map_err(|_| ()));
110
111    lp.run();
112    ex.destroy();
113}

More examples

Hide additional examples

examples/abstract.rs (line 70)

55fn main() {
56    futures_glib::init();
57
58    let path = b"named-socket";
59
60    let cx = MainContext::default(|cx| cx.clone());
61    let lp = MainLoop::new(None);
62    let ex = Executor::new();
63    ex.attach(&cx);
64
65    let listener = UnixListener::bind_abstract(path, &cx).unwrap();
66
67    let remote = ex.remote();
68
69    let inner_ex = ex.clone();
70    let incoming = listener.incoming()
71        .for_each(move |(stream, _addr)| {
72            let (reader, writer) = stream.split();
73            let mut framed_writer = FramedWrite::new(writer, LineCodec);
74            let framed_reader = FramedRead::new(reader, LineCodec);
75
76            inner_ex.spawn(framed_reader.and_then(|value| {
77                println!("Received: {:?}", value);
78                Ok(())
79            }).for_each(move |_| {
80                if let Ok(AsyncSink::Ready) = framed_writer.start_send("Received".to_string()) {
81                    framed_writer.poll_complete().unwrap();
82                }
83                Ok(())
84            }).map_err(|_| ()));
85            Ok(())
86        })
87        .map_err(|_| ());
88
89    ex.spawn(incoming);
90
91    thread::spawn(move || {
92        remote.spawn(move |ex: Executor| {
93            let connection = UnixStream::connect_abstract(path, &cx).unwrap();
94            let exe = ex.clone();
95            let future = connection.and_then(move |stream| {
96                let (reader, writer) = stream.split();
97                let framed_writer = FramedWrite::new(writer, LineCodec);
98                let framed_reader = FramedRead::new(reader, LineCodec);
99                exe.spawn(framed_reader.for_each(|value| {
100                    println!("Thread received: {:?}", value);
101                    Ok(())
102                }).map_err(|_| ()));
103                exe.spawn(framed_writer.send("Hello".to_string())
104                         .map(|_| ())
105                         .map_err(|_| ()));
106                Ok(())
107            })
108                .map_err(|_| ());
109            ex.spawn(future);
110            Ok(())
111        });
112    });
113
114    lp.run();
115    ex.destroy();
116}

examples/named-splitted.rs (line 72)

56fn main() {
57    futures_glib::init();
58
59    let path = "/tmp/named.socket";
60
61    let cx = MainContext::default(|cx| cx.clone());
62    let lp = MainLoop::new(None);
63    let ex = Executor::new();
64    ex.attach(&cx);
65
66    remove_file(path).ok();
67    let listener = UnixListener::bind(path, &cx).unwrap();
68
69    let remote = ex.remote();
70
71    let inner_ex = ex.clone();
72    let incoming = listener.incoming()
73        .for_each(move |(stream, _addr)| {
74            let (reader, writer) = stream.split();
75            let mut framed_writer = FramedWrite::new(writer, LineCodec);
76            let framed_reader = FramedRead::new(reader, LineCodec);
77
78            inner_ex.spawn(framed_reader.and_then(|value| {
79                println!("Received: {:?}", value);
80                Ok(())
81            }).for_each(move |_| {
82                if let Ok(AsyncSink::Ready) = framed_writer.start_send("Received".to_string()) {
83                    framed_writer.poll_complete().unwrap();
84                }
85                Ok(())
86            }).map_err(|_| ()));
87            Ok(())
88        })
89        .map_err(|_| ());
90
91    ex.spawn(incoming);
92
93    thread::spawn(move || {
94        remote.spawn(move |ex: Executor| {
95            let connection = UnixStream::connect(path, &cx);
96            let exe = ex.clone();
97            let future = connection.and_then(move |stream| {
98                let (reader, writer) = stream.split();
99                let framed_writer = FramedWrite::new(writer, LineCodec);
100                let framed_reader = FramedRead::new(reader, LineCodec);
101                exe.spawn(framed_reader.for_each(|value| {
102                    println!("Thread received: {:?}", value);
103                    Ok(())
104                }).map_err(|_| ()));
105                exe.spawn(framed_writer.send("Hello".to_string())
106                         .map(|_| ())
107                         .map_err(|_| ()));
108                Ok(())
109            })
110                .map_err(|_| ());
111            ex.spawn(future);
112            Ok(())
113        });
114    });
115
116    lp.run();
117    ex.destroy();
118}