From 4cead5a94f18211aaaa9a6060fa1caef0aaa9669 Mon Sep 17 00:00:00 2001 From: Gregor Reitzenstein Date: Fri, 30 Oct 2020 15:19:01 +0100 Subject: [PATCH] More code --- schema | 2 +- src/app.rs | 7 ++- src/main.rs | 11 +++- src/schema.rs | 155 ++++++++++++++++++++++++++++---------------------- src/ui/mod.rs | 6 +- 5 files changed, 108 insertions(+), 73 deletions(-) diff --git a/schema b/schema index 2b242d4..a4667b9 160000 --- a/schema +++ b/schema @@ -1 +1 @@ -Subproject commit 2b242d4f5c9ee9a608e57b4d4694eeabe9c6ee47 +Subproject commit a4667b94f331f9f624416bbbb951fe78d5304d26 diff --git a/src/app.rs b/src/app.rs index e274bb5..ee4b570 100644 --- a/src/app.rs +++ b/src/app.rs @@ -31,6 +31,7 @@ pub struct Sute { signal: S, inputs: Inputs, api: Option>, + new: bool } impl Sute { @@ -44,6 +45,7 @@ impl Sute { signal: s, inputs: inputs, api: Some(ConnState::Connecting(api)), + new: true } } @@ -66,6 +68,10 @@ impl Sute { _ => {} } } + + pub fn get_state(&self) -> SuteState { + self.state.get_cloned() + } } impl + Unpin, F: Future + Unpin> Signal for Sute { @@ -86,7 +92,6 @@ impl + Unpin, F: Future + Unpin> Signal fo } // TODO chunk this? - Pin::new(&mut self.statesig).poll_change(cx) } } diff --git a/src/main.rs b/src/main.rs index de13248..3ba3a9a 100644 --- a/src/main.rs +++ b/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))?; - } else { + terminal.draw(|f| ui::draw_ui(f, &mut state))?; } else { break; } } diff --git a/src/schema.rs b/src/schema.rs index 7ab5dc3..4364038 100644 --- a/src/schema.rs +++ b/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 { - Self { stream } + pub fn new(stream: TcpStream, bffh: connection_capnp::bootstrap::Client) -> Self { + Self { stream, bffh } } pub fn connect(addr: A) -> impl Future { 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(); - if api.authenticate().await.unwrap() { - println!("Authentication successful"); - } else { - println!("Authentication failed!"); - } + let mut rpc_system = RpcSystem::new(network, None); + let bffh: connection_capnp::bootstrap::Client + = rpc_system.bootstrap(rpc_twoparty_capnp::Side::Server); - 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(); - let mut builder = outer.init_root::().init_greet(); + async fn authenticate(&mut self) { + 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); - builder.set_major(version.0); - 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 { - 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"); + for t in m.get().unwrap().get_mechs().unwrap().iter() { + println!("{}", t.unwrap()); } - - Ok(self.receive_challenge().await?) } - fn send_authentication_request(&mut self, mech: &str, init: Option<&[u8]>) -> impl Future { - let mut outer = capnp::message::Builder::new_default(); - let mut builder = outer.init_root::() - .init_auth() - .init_request(); - builder.set_mechanism(mech); + ///// Authenticate to the server. Returns true on success, false on error + //async fn authenticate(&mut self) -> Result { + // 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 Some(data) = init { - builder.init_initial_response().set_initial(data); - } + // if let rsasl::Step::Done(data) = sess.step(&[]).unwrap() { + // self.send_authentication_request("PLAIN", Some(&data)).await; + // } else { + // println!("Sasl said moar data"); + // } - let stream = self.stream.clone(); - capnp_futures::serialize::write_message(stream, outer).map(|r| r.unwrap()) - } + // Ok(self.receive_challenge().await?) + //} - async fn receive_challenge(&mut self) -> Result { - let message = capnp_futures::serialize::read_message(&mut self.stream, capnp::message::ReaderOptions::default()).await.unwrap().unwrap(); - let m = message.get_root::().unwrap(); + //fn send_authentication_request(&mut self, mech: &str, init: Option<&[u8]>) -> impl Future { + // let mut outer = capnp::message::Builder::new_default(); + // let mut builder = outer.init_root::() + // .init_auth() + // .init_request(); + // builder.set_mechanism(mech); - 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); - } - } - } + // if let Some(data) = init { + // builder.init_initial_response().set_initial(data); + // } - 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 { + // let message = capnp_futures::serialize::read_message(&mut self.stream, capnp::message::ReaderOptions::default()).await.unwrap().unwrap(); + // let m = message.get_root::().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::(); + + 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::().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(()) } diff --git a/src/ui/mod.rs b/src/ui/mod.rs index c1a86f2..b5c246a 100644 --- a/src/ui/mod.rs +++ b/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(f: &mut Frame, 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(f: &mut Frame, 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(f: &mut Frame, 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(f: &mut Frame, app: &mut SuteState, layout_chunk: Re } fn draw_command_line(f: &mut Frame, 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);