🚧 Basic ProcessHandler works!

src/comp.rs

@@ -0,0 +1,31 @@
+use crate::process::{ProcessEvent, ProcessHandler};
+use tokio::sync::mpsc::unbounded_channel;
+use tokio_util::sync::CancellationToken;
+
+pub async fn run_compositor(token: CancellationToken) {
+	let (tx, mut rx) = unbounded_channel::<ProcessEvent>();
+	ProcessHandler::new(tx, &token).run("cosmic-comp", vec![]);
+	let span = info_span!("cosmic-comp");
+	let _enter = span.enter();
+	while let Some(event) = rx.recv().await {
+		match event {
+			ProcessEvent::Started => {
+				info!("started");
+			}
+			ProcessEvent::Stdout(line) => {
+				info!("{}", line);
+			}
+			ProcessEvent::Stderr(line) => {
+				error!("{}", line);
+			}
+			ProcessEvent::Ended(Some(status)) => {
+				error!("exited with status {}", status);
+				return;
+			}
+			ProcessEvent::Ended(None) => {
+				error!("exited");
+				return;
+			}
+		}
+	}
+}

src/main.rs

@@ -2,9 +2,13 @@
 #[macro_use]
 extern crate tracing;
 
+mod comp;
 mod process;
 
+use async_signals::Signals;
 use color_eyre::{eyre::WrapErr, Result};
+use futures_util::StreamExt;
+use tokio_util::sync::CancellationToken;
 use tracing::metadata::LevelFilter;
 use tracing_subscriber::{fmt, prelude::*, EnvFilter};
 
@@ -24,5 +28,22 @@ async fn main() -> Result<()> {
 
 	info!("Starting cosmic-session");
 
+	let token = CancellationToken::new();
+
+	tokio::spawn(comp::run_compositor(token.child_token()));
+
+	let mut signals = Signals::new(vec![libc::SIGTERM, libc::SIGINT]).unwrap();
+	while let Some(signal) = signals.next().await {
+		match signal {
+			libc::SIGTERM | libc::SIGINT => {
+				info!("received request to terminate");
+				token.cancel();
+				tokio::time::sleep(std::time::Duration::from_secs(5)).await;
+				break;
+			}
+			_ => unreachable!("received unhandled signal {}", signal),
+		}
+	}
+
 	Ok(())
 }