this ain't work

2017-06-02 00:42:57 +02:00 · 2017-06-02 00:42:57 +02:00 · 212d9e7e7e
commit 212d9e7e7e
4 changed files with 272 additions and 0 deletions
--- a/src/lib.rs
+++ b/src/lib.rs
@ -0,0 +1,112 @@
+extern crate futures;
+extern crate tokio_core;
+extern crate xml;
+
+use std::net::SocketAddr;
+use std::net::ToSocketAddrs;
+use std::sync::Arc;
+use std::io::ErrorKind;
+use futures::{Future, BoxFuture, Sink, Poll};
+use futures::stream::{Stream, iter};
+use futures::future::result;
+use tokio_core::reactor::Handle;
+use tokio_core::io::Io;
+use tokio_core::net::TcpStream;
+
+mod xmpp_codec;
+use xmpp_codec::*;
+
+
+// type FullClient = sasl::Client<StartTLS<TCPConnection>>
+
+type Event = ();
+type Error = std::io::Error;
+
+struct TCPStream {
+    source: Box<Stream<Item=Event, Error=std::io::Error>>,
+    sink: Arc<Box<futures::stream::SplitSink<tokio_core::io::Framed<tokio_core::net::TcpStream, xmpp_codec::XMPPCodec>>>>,
+}
+
+impl TCPStream {
+    pub fn connect(addr: &SocketAddr, handle: &Handle) -> BoxFuture<Arc<TCPStream>, std::io::Error> {
+        TcpStream::connect(addr, handle)
+            .and_then(|stream| {
+                let (sink, source) = stream.framed(XMPPCodec::new())
+                // .framed(UTF8Codec::new())
+                    .split();
+                
+                sink.send(Packet::StreamStart)
+                    .and_then(|sink| result(Ok((Arc::new(Box::new(sink)), source))))
+            })
+            .and_then(|(sink, source)| {
+                let sink1 = sink.clone();
+                let source = source
+                    .map(|items| iter(items.into_iter().map(Ok)))
+                    .flatten()
+                    .filter_map(move |pkt| Self::process_packet(pkt, &sink1))
+                // .for_each(|ev| {
+                //     match ev {
+                //         Packet::Stanza
+                //         _ => (),
+                //     }
+                //     Ok(println!("xmpp: {:?}", ev))
+                // })
+                // .boxed();
+                    ;
+                result(Ok(Arc::new(TCPStream {
+                    source: Box::new(source),
+                    sink: sink,
+                })))
+            }).boxed()
+            //.map_err(|e| std::io::Error::new(ErrorKind::Other, e));
+    }
+
+    fn process_packet<S>(pkt: Packet, sink: &Arc<S>) -> Option<Event>
+        where S: Sink<SinkItem=Packet, SinkError=std::io::Error> {
+
+        println!("pkt: {:?}", pkt);
+        None
+    }
+}
+
+struct ClientStream {
+    inner: TCPStream,
+}
+
+impl ClientStream {
+    pub fn connect(jid: &str, password: &str, handle: &Handle) -> Box<Future<Item=Self, Error=std::io::Error>> {
+        let addr = "[2a01:4f8:a0:33d0::5]:5222"
+            .to_socket_addrs().unwrap()
+            .next().unwrap();
+        let stream =
+            TCPStream::connect(&addr, handle)
+            .and_then(|stream| {
+                Ok(ClientStream {
+                    inner: stream
+                })
+            });
+        Box::new(stream)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use tokio_core::reactor::Core;
+
+    #[test]
+    fn it_works() {
+        let mut core = Core::new().unwrap();
+        let client = super::ClientStream::connect(
+            "astro@spaceboyz.net",
+            "...",
+            &core.handle()
+        ).and_then(|stream| {
+            stream.inner.source.boxed().for_each(|item| {
+                Ok(println!("stream item: {:?}", item))
+            })
+        }).boxed();
+        core.run(client).unwrap();
+    }
+
+    // TODO: test truncated utf8
+}