hackclub/burrow
1
0
Fork 0
Code Pull requests Releases Packages Activity Actions 4

Tested with mock grpc server

Browse source
This commit is contained in:
dav 2024-07-20 12:59:02 -07:00 • committed by David Zhong
parent 87cea6bf64
commit 9a262a1243
3 changed files with 41 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

2
burrow-gtk/src/components/app.rs
View file

@ -122,7 +122,6 @@ impl AsyncComponent for App {
_root: &Self::Root,
) {
loop {
tokio::time::sleep(RECONNECT_POLL_TIME).await;
{
let mut daemon_client = self.daemon_client.lock().await;
let mut disconnected_daemon_client = false;
@ -153,6 +152,7 @@ impl AsyncComponent for App {
}
}
}
tokio::time::sleep(RECONNECT_POLL_TIME).await;
}
}
}

1
burrow-gtk/src/components/mod.rs
View file

@ -3,7 +3,6 @@ use adw::prelude::*;
use gtk::Align;
use relm4::{
component::{
worker::{Worker, WorkerController},
AsyncComponent, AsyncComponentController, AsyncComponentParts, AsyncComponentSender,
AsyncController,
},

85
burrow-gtk/src/components/switch_screen.rs
View file

@ -1,5 +1,8 @@
use super::*;
use std::time::Duration;
use std::{
thread::{self, JoinHandle},
time::Duration,
};
const RECONNECT_POLL_TIME: Duration = Duration::from_secs(3);
@ -8,8 +11,7 @@ pub struct SwitchScreen {
switch: gtk::Switch,
switch_screen: gtk::Box,
disconnected_banner: adw::Banner,
_tunnel_state_worker: WorkerController<AsyncTunnelStateHandler>,
tunnel_state_worker: JoinHandle<()>,
}
pub struct SwitchScreenInit {
@ -18,13 +20,12 @@ pub struct SwitchScreenInit {
#[derive(Debug, PartialEq, Eq)]
pub enum SwitchScreenMsg {
None,
DaemonReconnect,
DaemonDisconnect,
Start,
Stop,
SwitchSetStart,
SwitchSetStop,
TunnelStateStopped,
TunnelStateRunning,
}
#[relm4::component(pub, async)]
@ -97,6 +98,7 @@ impl AsyncComponent for SwitchScreen {
}
let switch_sender = sender.clone();
let tunnel_state_sender = sender.clone();
let widgets = view_output!();
if initial_daemon_server_down {
@ -111,9 +113,9 @@ impl AsyncComponent for SwitchScreen {
switch: widgets.switch.clone(),
switch_screen: widgets.switch_screen.clone(),
disconnected_banner: widgets.setup_banner.clone(),
_tunnel_state_worker: AsyncTunnelStateHandler::builder()
.detach_worker(())
.forward(sender.input_sender(), |_| SwitchScreenMsg::None),
tunnel_state_worker: thread::spawn(move || {
tunnel_state_worker(tunnel_state_sender);
}),
};
widgets.switch.set_active(false);
@ -133,21 +135,21 @@ impl AsyncComponent for SwitchScreen {
let mut client = tunnel_client::TunnelClient::new(daemon_client);
match msg {
Self::Input::Start => {
if let Err(_e) = client.tunnel_start(burrow_rpc::Empty {}).await {
if let Err(e) = client.tunnel_start(burrow_rpc::Empty {}).await {
disconnected_daemon_client = true;
}
}
Self::Input::Stop => {
if let Err(_e) = client.tunnel_stop(burrow_rpc::Empty {}).await {
if let Err(e) = client.tunnel_stop(burrow_rpc::Empty {}).await {
disconnected_daemon_client = true;
}
}
Self::Input::SwitchSetStart => {
self.switch.set_active(true);
}
Self::Input::SwitchSetStop => {
Self::Input::TunnelStateStopped => {
self.switch.set_active(false);
}
Self::Input::TunnelStateRunning => {
self.switch.set_active(true);
}
_ => {}
}
} else {
@ -166,39 +168,32 @@ impl AsyncComponent for SwitchScreen {
}
}
}
struct AsyncTunnelStateHandler;
impl Worker for AsyncTunnelStateHandler {
type Init = ();
type Input = ();
type Output = SwitchScreenMsg;
fn init(_: Self::Init, _sender: ComponentSender<Self>) -> Self {
Self
}
fn update(&mut self, _: (), sender: ComponentSender<Self>) {
let rt = tokio::runtime::Runtime::new().unwrap();
let task = rt.spawn(async move {
loop {
let conn = daemon::daemon_connect().await;
if let Ok(conn) = conn {
let mut client = tunnel_client::TunnelClient::new(conn);
if let Ok(mut res) = client.tunnel_status(burrow_rpc::Empty {}).await {
let stream = res.get_mut();
while let Ok(Some(msg)) = stream.message().await {
sender
.output(match msg.state() {
burrow_rpc::State::Running => SwitchScreenMsg::SwitchSetStart,
burrow_rpc::State::Stopped => SwitchScreenMsg::SwitchSetStop,
})
.unwrap();
fn tunnel_state_worker(sender: AsyncComponentSender<SwitchScreen>) {
let rt = tokio::runtime::Runtime::new().unwrap();
let task = rt.spawn(async move {
loop {
let sender = sender.input_sender();
let conn = daemon::daemon_connect().await;
if let Ok(conn) = conn {
let mut client = tunnel_client::TunnelClient::new(conn);
if let Ok(mut res) = client.tunnel_status(burrow_rpc::Empty {}).await {
let stream = res.get_mut();
while let Ok(Some(msg)) = stream.message().await {
match msg.state() {
burrow_rpc::State::Stopped => {
sender.send(SwitchScreenMsg::TunnelStateStopped)
}
burrow_rpc::State::Running => {
sender.send(SwitchScreenMsg::TunnelStateRunning)
}
}
.unwrap();
}
}
tokio::time::sleep(RECONNECT_POLL_TIME).await;
}
});
rt.block_on(task).unwrap();
}
tokio::time::sleep(RECONNECT_POLL_TIME).await;
}
});
rt.block_on(task).unwrap();
}