FabInfra-Mirror/sute
1
0
Fork 0
mirror of https://gitlab.com/fabinfra/fabaccess/sute.git synced 2025-03-12 06:31:53 +01:00
Code Issues Packages Projects Releases Wiki Activity

More code

Browse Source
This commit is contained in:
Gregor Reitzenstein 2020-10-30 15:19:01 +01:00
parent 37e9b45338
commit 4cead5a94f
5 changed files with 108 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
schema

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

7
src/app.rs
View File

@ -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)
}
}

11
src/main.rs
View File

@ -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;
}
}

155
src/schema.rs
View File

@ -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<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();
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::<connection_capnp::message::Builder>().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<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");
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<Output=()> {
let mut outer = capnp::message::Builder::new_default();
let mut builder = outer.init_root::<connection_capnp::message::Builder>()
.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<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 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<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();
//fn send_authentication_request(&mut self, mech: &str, init: Option<&[u8]>) -> impl Future<Output=()> {
// let mut outer = capnp::message::Builder::new_default();
// 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 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<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(())
}

6
src/ui/mod.rs
View File

@ -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);