Create GUI

Cargo.toml

@@ -23,6 +23,8 @@ clap = { version = "4.5.49", features = ["derive", "cargo", "wrap_help"] }
 crossterm = { version = "0.27.0", features = ["event-stream"] }
 derive_more = "0.99.20"
 digest = "0.10.7"
+eframe = { version = "0.34", optional = true, default-features = false, features = ["accesskit", "default_fonts", "wayland", "web_screen_reader", "x11", "glow", "persistence"] }
+egui = { version = "0.34", optional = true }
 flate2 = "1.1.4"
 format-bytes = "0.3.0"
 futures = { version = "0.3.31", default-features = false, features = ["std"] }
@@ -40,6 +42,7 @@ lz4_flex = { version = "0.11.6", default-features = false, features = [
 # aliased to appease cargo-machete because the crate's namespace is md5 rather than md_5
 md5 = { package = "md-5", version = "0.10.6", default-features = false }
 process_path = "0.1.4"
+rfd = "0.17"
 ratatui = { version = "0.26.3", default-features = false, features = [
   "crossterm",
 ] }
@@ -65,6 +68,9 @@ tracing-unwrap = "1.0.1"
 which = "6.0.3"
 xz2 = { version = "0.1.7", features = ["static"] }
 
+[features]
+gui = ["dep:egui", "dep:eframe"]
+
 [dev-dependencies]
 approx = "0.5.1"
 assert_matches = "1.5.0"

src/orchestrator/analyze_input.rs → src/facade/analyze_input.rs

@@ -7,7 +7,7 @@ use bytes::Bytes;
 use crate::{compression::CompressionFormat, hash::HashAlg, util::candidate::Candidates};
 
 /// Result of analyzing an input file for its properties.
-pub struct InputAnalysis {
+pub struct FileAnalysis {
     pub compression: Candidates<CompressionCandidate>,
     pub hash_file: Candidates<HashFile>,
 }

src/orchestrator/herder_facade/facade.rs → src/facade/legacy_facade/facade.rs

@@ -7,7 +7,7 @@ use tracing::{debug, trace};
 use tracing_unwrap::ResultExt;
 
 use super::{
-    DaemonError, HerdHandle, HerderFacade, StartWriterError,
+    DaemonError, HerdHandle, LegacyFacade, StartWriterError,
     client::{HerderClient, HerderClientFactory, LazyHerderClient, RawHerderClient},
 };
 use crate::{
@@ -16,11 +16,11 @@ use crate::{
     ipc_common::read_msg_async,
 };
 
-/// Make the actual prod-used [HerderFacade].
+/// Make the actual prod-used [LegacyFacade].
 ///
 /// Doing it this way with a function is so that we can hide all of those ugly
-/// ugly ugly type signatures under a nice `impl HerderFacade + 'static`!
-pub fn make_herder_facade_impl(log_path: &str) -> impl HerderFacade + 'static {
+/// ugly ugly type signatures under a nice `impl LegacyFacade + 'static`!
+pub fn make_legacy_facade_impl(log_path: &str) -> impl LegacyFacade + 'static {
     let event_demux = Arc::new(std::sync::Mutex::new(EventDemuxMap::new()));
 
     /// Simple implementor of [HerderClientFactory].
@@ -61,7 +61,7 @@ pub fn make_herder_facade_impl(log_path: &str) -> impl HerderFacade + 'static {
     }
 }
 
-/// Implementation of the actual [HerderFacade] used by Caligula.
+/// Implementation of the actual [LegacyFacade] used by Caligula.
 struct HerderFacadeImpl<Std, Esc> {
     event_demux: Arc<std::sync::Mutex<EventDemuxMap<u64, TopLevelHerdEvent>>>,
     next_writer_id: u64,
@@ -70,7 +70,7 @@ struct HerderFacadeImpl<Std, Esc> {
     escalated_daemon: Esc,
 }
 
-impl<Std, Esc> HerderFacade for HerderFacadeImpl<Std, Esc>
+impl<Std, Esc> LegacyFacade for HerderFacadeImpl<Std, Esc>
 where
     Std: HerderClient,
     Esc: HerderClient,

src/orchestrator/herder_facade/mod.rs → src/facade/legacy_facade/mod.rs

@@ -1,13 +1,13 @@
 //! WARNING: HERE THERE BE DRAGONS
 //!
-//! The good parts of this submodule will get assimilated into orchestrator once
-//! I get back to working on the stdiomux branch. Don't rely on this module
-//! whatsoever! Orchestrator is mildly stable though.
+//! The good parts of this submodule will get assimilated into CaligulaFacade
+//! once I get back to working on the stdiomux branch. Don't rely on this module
+//! whatsoever! CaligulaFacade is mildly stable though.
 
 mod client;
 mod facade;
 
-pub use facade::make_herder_facade_impl;
+pub use facade::make_legacy_facade_impl;
 use futures::stream::BoxStream;
 
 use crate::herder_api::{HerdAction, HerdEvent, TopLevelHerdEvent};
@@ -20,7 +20,7 @@ use crate::herder_api::{HerdAction, HerdEvent, TopLevelHerdEvent};
 ///
 /// Making it a trait is so that we can easily test the UI as a separate
 /// component from the backend.
-pub trait HerderFacade {
+pub trait LegacyFacade {
     async fn start_herd<A: HerdAction>(
         &mut self,
         action: A,

src/facade/mod.rs

@@ -0,0 +1,112 @@
+//! Exposes the [`CaligulaFacade`], which is a facade that orchestrates all
+//! "high-level" work and tracks the state of worker tasks.
+
+use std::path::PathBuf;
+
+pub use self::{
+    disks::DiskList,
+    legacy_facade::{DaemonError, StartWriterError},
+    workflow::{
+        Orchestrator, OrchestratorExt,
+        write_verify::{WVState, WriteVerifyWorkflow, WriteVerifyWorkflowError},
+    },
+};
+use crate::{
+    escalation::EscalationMethod,
+    facade::{analyze_input::FileAnalysis, workflow::hash::HashWorkflow},
+};
+
+mod analyze_input;
+mod disks;
+mod legacy_facade;
+mod real;
+pub mod watch;
+pub mod workflow;
+
+/// Main facade for UI implementations to interact with the rest of the
+/// program's logic.
+///
+/// This trait is split up into several subtraits, each representing a different
+/// kind of action the UI can take.
+///
+/// The API for this can be considered "mostly" stable. I'll be changing out the
+/// error types, but in general, the overall shape of this API can be used for
+/// new UI developments.
+pub trait CaligulaFacade:
+    Sync
+    + Send
+    + DiskWatcher
+    + FileAnalyzer
+    + Escalator
+    + Orchestrator<WriteVerifyWorkflow>
+    + Orchestrator<HashWorkflow>
+    + 'static
+{
+}
+
+impl<F> CaligulaFacade for F where
+    F: Sync
+        + Send
+        + DiskWatcher
+        + FileAnalyzer
+        + Escalator
+        + Orchestrator<WriteVerifyWorkflow>
+        + Orchestrator<HashWorkflow>
+        + 'static
+{
+}
+
+/// Represents an interface to the disk querying subsystem.
+pub trait DiskWatcher {
+    /// Get a handle for watching the list of disks available. This may update
+    /// as disks are added and removed to the system.
+    ///
+    /// Although this returns a handle immediately, the initial results may take
+    /// a while to load.
+    #[expect(unused, reason = "Stub interface created for later use.")]
+    fn watch_disks(&self) -> watch::Watch<DiskList>;
+}
+
+/// Represents an interface to the file analysis subsystem.
+pub trait FileAnalyzer {
+    /// Analyze a file to guess how we should handle it.
+    ///
+    /// This is a fairly fast operation, expected to take 1-3 seconds to run.
+    ///
+    /// Returns the results of the analysis, or an error if the file could not
+    /// be read. This method is fault-tolerant, so the only errors that can
+    /// cause this operation to fail are I/O errors.
+    ///
+    /// The intended workflow is that you call it once, to fill up your UI's
+    /// wizard with data, and then ask the user for more information if
+    /// there's anything that's not certain.
+    #[expect(unused, reason = "Stub interface created for later use.")]
+    async fn analyze_file(&self, input: PathBuf) -> std::io::Result<FileAnalysis>;
+}
+
+/// Represents an interface to the privilege escalation subsystem.
+pub trait Escalator {
+    /// Attempt to spawn a child process as root using the provided escalation
+    /// method (or [`None`] to automatically guess which one to use).
+    ///
+    /// Returns [`Ok`] if we successfully managed to escalate, or an error if we
+    /// failed. If we were already escalated before this was called, returns
+    /// [`Ok`].
+    ///
+    /// Once this is called, all future workflows will be routed through the
+    /// escalated child process rather than executing at the parent's
+    /// permission level!
+    ///
+    /// If your requested method involves the terminal, you should switch back
+    /// to the non-alternate screen before calling this.
+    async fn escalate(&self, method: Option<EscalationMethod>) -> Result<(), DaemonError>;
+
+    /// Returns whether or not we have a child process running as root.
+    #[expect(unused, reason = "Stub interface created for later use.")]
+    fn is_escalated(&self) -> bool;
+}
+
+/// Make the actual prod-used CaligulaFacade implementation.
+pub fn make_real_facade(log_path: &str) -> impl CaligulaFacade {
+    self::real::FacadeImpl::new(legacy_facade::make_legacy_facade_impl(log_path))
+}

src/facade/real.rs

@@ -0,0 +1,136 @@
+use std::{path::PathBuf, sync::Arc, time::Instant};
+
+use futures::StreamExt;
+
+use super::legacy_facade::{DaemonError, LegacyFacade};
+use crate::{
+    escalation::EscalationMethod,
+    facade::{
+        DiskList, DiskWatcher, Escalator, FileAnalyzer, Orchestrator, WVState, WriteVerifyWorkflow,
+        analyze_input::FileAnalysis,
+        watch::Watch,
+        workflow::hash::{HashWorkflow, HashingState},
+    },
+};
+
+/// Actual CaligulaFacade implementation used by Caligula.
+pub struct FacadeImpl<H> {
+    inner: tokio::sync::Mutex<Inner<H>>,
+}
+
+struct Inner<H> {
+    // TODO: get rid of the entire herder facade thing altogether. just assimilate the good parts
+    // into CaligulaFacade.
+    h: H,
+    escalation: Option<Option<EscalationMethod>>,
+}
+
+impl<H> FacadeImpl<H> {
+    pub fn new(h: H) -> Self {
+        Self {
+            inner: Inner {
+                h,
+                escalation: None,
+            }
+            .into(),
+        }
+    }
+}
+
+impl<H: LegacyFacade + Send + 'static> Orchestrator<WriteVerifyWorkflow> for FacadeImpl<H> {
+    async fn start_workflow(&self, params: WriteVerifyWorkflow) -> Watch<WVState> {
+        tracing::info!("Requesting herder to start");
+
+        // request the herder to start the action
+        let mut inner = self.inner.lock().await;
+        let esc = inner.escalation.is_some();
+        let handle: crate::facade::legacy_facade::HerdHandle<
+            crate::herder_api::write_verify::WriteVerifyEvent,
+        > = match inner.h.start_herd(params.make_child_config(), esc).await {
+            Ok(handle) => handle,
+            Err(e) => {
+                // oh god what a shitshow
+                // TODO: refactor the shit out of this thing
+                return Watch {
+                    rx: tokio::sync::watch::channel(WVState::error(
+                        Instant::now(),
+                        match e {
+                            crate::facade::StartWriterError::UnexpectedFirstStatus(s) => {
+                                crate::facade::WriteVerifyWorkflowError::Unexpected(s)
+                            }
+                            crate::facade::StartWriterError::Failed(f) => {
+                                crate::facade::WriteVerifyWorkflowError::Worker(f)
+                            }
+                            crate::facade::StartWriterError::DaemonError(daemon_error) => {
+                                crate::facade::WriteVerifyWorkflowError::Daemon(Arc::new(
+                                    daemon_error,
+                                ))
+                            }
+                        },
+                    ))
+                    .1,
+                };
+            }
+        };
+        drop(inner);
+
+        // create state reduction task
+        let (tx_state, rx_state) = tokio::sync::watch::channel(WVState::initial(
+            Instant::now(),
+            !params.compression.is_identity(),
+            handle.initial_info.input_file_bytes,
+        ));
+        let mut events = handle.events;
+        let _jh = tokio::spawn(async move {
+            while !tx_state.borrow().is_finished() && !tx_state.is_closed() {
+                let event = events.next().await;
+                tx_state.send_modify(move |state| {
+                    *state = std::mem::take(state).on_status(Instant::now(), event);
+                });
+            }
+        });
+        super::watch::Watch { rx: rx_state }
+    }
+}
+
+impl<H: LegacyFacade + Send + 'static> Orchestrator<HashWorkflow> for FacadeImpl<H> {
+    async fn start_workflow(&self, _workflow: HashWorkflow) -> Watch<HashingState> {
+        unimplemented!(
+            "Until this is implemented, for testing purposes, you may replace this with test values."
+        )
+    }
+}
+
+impl<H: LegacyFacade> Escalator for FacadeImpl<H> {
+    async fn escalate(&self, method: Option<EscalationMethod>) -> Result<(), DaemonError> {
+        let mut inner = self.inner.lock().await;
+        inner.escalation = Some(method);
+        inner.h.ensure_escalated_daemon().await?;
+        Ok(())
+    }
+
+    fn is_escalated(&self) -> bool {
+        // TODO: this is badly implemented but it's good enough for writing new UIs
+        // against. It will be improved when we get rid of herder facade.
+        let Ok(lock) = self.inner.try_lock() else {
+            return false;
+        };
+        lock.escalation.is_some()
+    }
+}
+
+impl<H> DiskWatcher for FacadeImpl<H> {
+    fn watch_disks(&self) -> Watch<DiskList> {
+        unimplemented!(
+            "Until this is implemented, for testing purposes, you may replace this with test values."
+        )
+    }
+}
+
+impl<H> FileAnalyzer for FacadeImpl<H> {
+    async fn analyze_file(&self, _input: PathBuf) -> std::io::Result<FileAnalysis> {
+        unimplemented!(
+            "Until this is implemented, for testing purposes, you may replace this with test values."
+        )
+    }
+}