More code

schema

@@ -1 +1 @@
-Subproject commit 2b242d4f5c9ee9a608e57b4d4694eeabe9c6ee47
+Subproject commit a4667b94f331f9f624416bbbb951fe78d5304d26

src/app.rs

@@ -31,6 +31,7 @@ pub struct Sute<S, F> {
     signal: S,
     inputs: Inputs,
     api: Option<ConnState<F>>,
+    new: bool
 }
 
 impl<S: Unpin, F: Unpin> Sute<S, F> {
@@ -44,6 +45,7 @@ impl<S: Unpin, F: Unpin> Sute<S, F> {
             signal: s,
             inputs: inputs,
             api: Some(ConnState::Connecting(api)),
+            new: true
         }
     }
 
@@ -66,6 +68,10 @@ impl<S: Unpin, F: Unpin> Sute<S, F> {
             _ => {}
         }
     }
+
+    pub fn get_state(&self) -> SuteState {
+        self.state.get_cloned()
+    }
 }
 
 impl<S: Signal<Item=(u16,u16)> + Unpin, F: Future<Output=Api> + Unpin> Signal for Sute<S, F> {
@@ -86,7 +92,6 @@ impl<S: Signal<Item=(u16,u16)> + Unpin, F: Future<Output=Api> + Unpin> Signal fo
         }
 
         // TODO chunk this?
-
         Pin::new(&mut self.statesig).poll_change(cx)
     }
 }

src/main.rs

@@ -49,10 +49,18 @@ fn main() -> Result<(), io::Error> {
     let mut terminal = Terminal::new(backend)?;
     terminal.hide_cursor()?;
 
+    // Refresh the screen once by resizing the terminal
+    if let Ok((x,y)) = termion::terminal_size() {
+        terminal.resize(tui::layout::Rect::new(0, 0, x,y)).unwrap();
+    }
+
     let resize = util::Resize::new()?;
     let api = schema::Api::connect(server);
     let app = app::Sute::new(resize, Box::pin(api));
 
+    let mut state = app.get_state();
+    terminal.draw(|f| ui::draw_ui(f, &mut state))?;
+
     let mut stream = app.to_stream();
     loop {
         if let Some(mut state) = smol::block_on(stream.next()) {
@@ -60,8 +68,7 @@ fn main() -> Result<(), io::Error> {
                 break;
             }
 
-            terminal.draw(|f| ui::draw_ui(f, &mut state))?;
+            terminal.draw(|f| ui::draw_ui(f, &mut state))?; } else {
-        } else {
             break;
         }
     }

src/schema.rs

@@ -24,96 +24,115 @@ mod api_capnp {
 const PLAIN: *const libc::c_char = b"PLAIN" as *const u8 as *const libc::c_char;
 
 pub struct Api {
-    stream: TcpStream
+    stream: TcpStream,
+    bffh: connection_capnp::bootstrap::Client,
 }
 
 impl Api {
-    pub fn new(stream: TcpStream) -> Self {
+    pub fn new(stream: TcpStream, bffh: connection_capnp::bootstrap::Client) -> Self {
-        Self { stream }
+        Self { stream, bffh }
     }
     pub fn connect<A: AsyncToSocketAddrs>(addr: A) -> impl Future<Output=Api> {
         let f = async {
             let mut stream = TcpStream::connect(addr).await.unwrap();
-            println!("Doing a hecking connect!");
 
-            let mut api = Api::new(stream);
+            handshake(&mut stream).await.unwrap();
+            let network = Box::new(twoparty::VatNetwork::new(stream.clone(), stream.clone(),
+                    rpc_twoparty_capnp::Side::Client, Default::default()));
 
-            api.handshake().await.unwrap();
+            let mut rpc_system = RpcSystem::new(network, None); 
-            if api.authenticate().await.unwrap() {
+            let bffh: connection_capnp::bootstrap::Client 
-                println!("Authentication successful");
+                = rpc_system.bootstrap(rpc_twoparty_capnp::Side::Server);
-            } else {
-                println!("Authentication failed!");
-            }
 
-            api
+            Api::new(stream, bffh)
         };
 
         f
     }
-    async fn handshake(&mut self) -> Result<(), io::Error> {
-        let host = "localhost";
-        let program = format!("{}-{}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"));
-        let version = (0u32,1u32);
 
-        let mut outer = capnp::message::Builder::new_default();
+    async fn authenticate(&mut self) {
-        let mut builder = outer.init_root::<connection_capnp::message::Builder>().init_greet();
+        let r = self.bffh.auth_request();
+        let auth = r.send().pipeline.get_auth();
+        let m = auth.mechanisms_request().send().promise.await.unwrap();
 
-        builder.set_host(host);
+        for t in m.get().unwrap().get_mechs().unwrap().iter() {
-        builder.set_major(version.0);
+            println!("{}", t.unwrap());
-        builder.set_minor(version.1);
-        builder.set_program(program);
-
-        capnp_futures::serialize::write_message(&mut self.stream, outer).await.unwrap();
-
-        println!("{}", program);
-
-        Ok(())
-    }
-
-    /// Authenticate to the server. Returns true on success, false on error
-    async fn authenticate(&mut self) -> Result<bool, io::Error> {
-        let mut sasl = SASL::new().unwrap();
-        let plain = std::ffi::CString::new("PLAIN").unwrap();
-        let mut sess = sasl.client_start(&plain).unwrap();
-        sess.set_property(rsasl::Property::GSASL_AUTHID, b"testuser");
-        sess.set_property(rsasl::Property::GSASL_PASSWORD, b"testpass");
-
-        if let rsasl::Step::Done(data) = sess.step(&[]).unwrap() {
-            self.send_authentication_request("PLAIN", Some(&data)).await;
-        } else {
-            println!("Sasl said moar data");
         }
-
-        Ok(self.receive_challenge().await?)
     }
 
-    fn send_authentication_request(&mut self, mech: &str, init: Option<&[u8]>) -> impl Future<Output=()> {
+    ///// Authenticate to the server. Returns true on success, false on error
-        let mut outer = capnp::message::Builder::new_default();
+    //async fn authenticate(&mut self) -> Result<bool, io::Error> {
-        let mut builder = outer.init_root::<connection_capnp::message::Builder>()
+    //    let mut sasl = SASL::new().unwrap();
-            .init_auth()
+    //    let plain = std::ffi::CString::new("PLAIN").unwrap();
-            .init_request();
+    //    let mut sess = sasl.client_start(&plain).unwrap();
-        builder.set_mechanism(mech);
+    //    sess.set_property(rsasl::Property::GSASL_AUTHID, b"testuser");
+    //    sess.set_property(rsasl::Property::GSASL_PASSWORD, b"testpass");
 
-        if let Some(data) = init {
+    //    if let rsasl::Step::Done(data) = sess.step(&[]).unwrap() {
-            builder.init_initial_response().set_initial(data);
+    //        self.send_authentication_request("PLAIN", Some(&data)).await;
-        }
+    //    } else {
+    //        println!("Sasl said moar data");
+    //    }
 
-        let stream = self.stream.clone();
+    //    Ok(self.receive_challenge().await?)
-        capnp_futures::serialize::write_message(stream, outer).map(|r| r.unwrap())
+    //}
-    }
 
-    async fn receive_challenge(&mut self) -> Result<bool, io::Error> {
+    //fn send_authentication_request(&mut self, mech: &str, init: Option<&[u8]>) -> impl Future<Output=()> {
-        let message = capnp_futures::serialize::read_message(&mut self.stream, capnp::message::ReaderOptions::default()).await.unwrap().unwrap();
+    //    let mut outer = capnp::message::Builder::new_default();
-        let m = message.get_root::<connection_capnp::message::Reader>().unwrap();
+    //    let mut builder = outer.init_root::<connection_capnp::message::Builder>()
+    //        .init_auth()
+    //        .init_request();
+    //    builder.set_mechanism(mech);
 
-        if let Ok(connection_capnp::message::Which::Auth(Ok(r))) = m.which() {
+    //    if let Some(data) = init {
-            if let Ok(auth_capnp::auth_message::Outcome(Ok(r))) = r.which() {
+    //        builder.init_initial_response().set_initial(data);
-                if let Ok(auth_capnp::outcome::Result::Successful) = r.get_result() {
+    //    }
-                    return Ok(true);
-                }
-            }
-        }
 
-        return Ok(false);
+    //    let stream = self.stream.clone();
-    }
+    //    capnp_futures::serialize::write_message(stream, outer).map(|r| r.unwrap())
+    //}
+
+    //async fn receive_challenge(&mut self) -> Result<bool, io::Error> {
+    //    let message = capnp_futures::serialize::read_message(&mut self.stream, capnp::message::ReaderOptions::default()).await.unwrap().unwrap();
+    //    let m = message.get_root::<connection_capnp::message::Reader>().unwrap();
+
+    //    if let Ok(connection_capnp::message::Which::Auth(Ok(r))) = m.which() {
+    //        if let Ok(auth_capnp::auth_message::Outcome(Ok(r))) = r.which() {
+    //            if let Ok(auth_capnp::outcome::Result::Successful) = r.get_result() {
+    //                return Ok(true);
+    //            }
+    //        }
+    //    }
+
+    //    return Ok(false);
+    //}
+}
+
+async fn handshake(mut stream: &mut TcpStream) -> Result<(), io::Error> {
+    let host = "localhost";
+    let program = format!("{}-{}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"));
+    let version = (0u32,1u32);
+
+    let mut message = capnp::message::Builder::new_default();
+    let mut builder = message.init_root::<connection_capnp::greeting::Builder>();
+
+    builder.set_host(host);
+    builder.set_major(version.0);
+    builder.set_minor(version.1);
+    builder.set_program(&program);
+
+    capnp_futures::serialize::write_message(&mut stream, message).await.unwrap();
+    if let Some(m) = capnp_futures::serialize::read_message(&mut stream, Default::default()).await.unwrap() {
+        let greeting = m.get_root::<connection_capnp::greeting::Reader>().unwrap();
+        let peer_host = greeting.get_host().unwrap();
+        let peer_program = greeting.get_program().unwrap();
+        let major = greeting.get_major();
+        let minor = greeting.get_minor();
+
+        println!("Peer {} running {} API {}.{}", peer_host, peer_program, major, minor)
+    } else {
+        println!("Oh noes");
+    }
+
+    Ok(())
 }

src/ui/mod.rs

@@ -1,7 +1,7 @@
 use tui::{
     backend::Backend,
     layout::{Layout, Direction, Constraint, Rect},
-    widgets::{Paragraph, Block, Borders},
+    widgets::{Paragraph, Block, Borders, Clear},
     Frame,
 };
 
@@ -18,18 +18,21 @@ pub fn draw_ui<B: Backend>(f: &mut Frame<B>, app: &mut SuteState) {
         )
         .split(f.size());
 
+
     draw_header(f, app, outer_layout[0]);
     draw_main(f, app, outer_layout[1]);
     draw_command_line(f, app, outer_layout[2]);
 }
 
 fn draw_header<B: Backend>(f: &mut Frame<B>, app: &mut SuteState, layout_chunk: Rect) {
+    f.render_widget(Clear, layout_chunk);
     f.render_widget(Block::default()
         .title("Header")
         .borders(Borders::ALL), layout_chunk);
 }
 
 fn draw_main<B: Backend>(f: &mut Frame<B>, app: &mut SuteState, layout_chunk: Rect) {
+    f.render_widget(Clear, layout_chunk);
     let chunk = Layout::default()
         .direction(Direction::Horizontal)
         .constraints([Constraint::Percentage(20), Constraint::Percentage(80)].as_ref())
@@ -40,6 +43,7 @@ fn draw_main<B: Backend>(f: &mut Frame<B>, app: &mut SuteState, layout_chunk: Re
 }
 
 fn draw_command_line<B: Backend>(f: &mut Frame<B>, app: &mut SuteState, layout_chunk: Rect) {
+    f.render_widget(Clear, layout_chunk);
     f.render_widget(Block::default()
         .title("Command line")
         .borders(Borders::ALL), layout_chunk);