lib: Encapsulate application setup

This commit is contained in:
Erik Kundt
2024-05-15 14:50:01 +02:00
parent f1df2ea2a9
commit f929fd8fe5
2 changed files with 62 additions and 11 deletions
+48
View File
@@ -8,9 +8,15 @@ pub mod task;
pub mod terminal;
pub mod ui;
use std::fmt::Debug;
use anyhow::Result;
use serde::ser::{Serialize, SerializeStruct, Serializer};
use store::State;
use task::Interrupted;
use tokio::sync::mpsc::{self, UnboundedReceiver, UnboundedSender};
use ui::{widget::Widget, Frontend};
/// An optional return value.
#[derive(Clone, Debug)]
@@ -97,3 +103,45 @@ impl<T> PageStack<T> {
}
}
}
/// A multi-producer, single-consumer message channel.
pub struct Channel<A> {
pub tx: UnboundedSender<A>,
pub rx: UnboundedReceiver<A>,
}
impl<A> Default for Channel<A> {
fn default() -> Self {
let (tx, rx) = mpsc::unbounded_channel();
Self { tx: tx.clone(), rx }
}
}
/// Initialize a `Store` with the `State` given and a `Frontend` with the `Widget` given,
/// and run their main loops concurrently. Connect them to the `Channel` and also to
/// an interrupt broadcast channel also initialized in this function.
pub async fn run<S, A, W, P>(channel: Channel<A>, state: S, root: W) -> Result<Option<P>>
where
S: State<P, Action = A> + Clone + Debug + Send + Sync + 'static,
W: Widget<State = S, Action = A>,
P: Clone + Debug + Send + Sync + 'static,
{
let (terminator, mut interrupt_rx) = task::create_termination();
let (store, state_rx) = store::Store::<A, S, P>::new();
let frontend = Frontend::<A>::new(channel.tx.clone());
tokio::try_join!(
store.main_loop(state, terminator, channel.rx, interrupt_rx.resubscribe()),
frontend.main_loop(Some(root), state_rx, interrupt_rx.resubscribe()),
)?;
if let Ok(reason) = interrupt_rx.recv().await {
match reason {
Interrupted::User { payload } => Ok(payload),
Interrupted::OsSignal => anyhow::bail!("exited because of an os sig int"),
}
} else {
anyhow::bail!("exited because of an unexpected error");
}
}
+14 -11
View File
@@ -10,7 +10,8 @@ use std::fmt::Debug;
use std::time::Duration;
use tokio::sync::broadcast;
use tokio::sync::mpsc::{self, UnboundedReceiver, UnboundedSender};
use tokio::sync::mpsc;
use tokio::sync::mpsc::UnboundedReceiver;
use crate::ui::widget::RenderProps;
@@ -34,16 +35,10 @@ pub struct Frontend<A> {
impl<A> Frontend<A> {
/// Create a new `Frontend` storing the sending end of a message channel.
pub fn new() -> (Self, UnboundedSender<A>, UnboundedReceiver<A>) {
let (action_tx, action_rx) = mpsc::unbounded_channel();
(
Self {
action_tx: action_tx.clone(),
},
action_tx,
action_rx,
)
pub fn new(action_tx: mpsc::UnboundedSender<A>) -> Self {
Self {
action_tx: action_tx.clone(),
}
}
/// By calling `main_loop`, the `Frontend` will wait for new messages being sent
@@ -115,4 +110,12 @@ impl<A> Frontend<A> {
result
}
// pub fn action_tx(&self) -> UnboundedSender<A> {
// self.action_tx.clone()
// }
// pub fn action_rx(&self) -> UnboundedReceiver<A> {
// self.action_rx.clone()
// }
}