From 308ad5ccfdf6638e55cb4b071e2f65ca35dbd545 Mon Sep 17 00:00:00 2001 From: Hannes Kuchelmeister Date: Sun, 28 Apr 2024 00:41:13 +0200 Subject: [PATCH] add populate factory using toolboxes on machine --- Cargo.lock | 14 +- Cargo.toml | 2 + .../org.kuchelmeister.ToolboxTuner.Devel.json | 7 +- src/app.rs | 25 +- src/factories/container_list.rs | 23 +- src/main.rs | 1 + src/util.rs | 1 + src/util/toolbox.rs | 427 ++++++++++++++++++ 8 files changed, 470 insertions(+), 30 deletions(-) create mode 100644 src/util.rs create mode 100644 src/util/toolbox.rs diff --git a/Cargo.lock b/Cargo.lock index 8f7014f..5a57cc6 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1032,18 +1032,18 @@ checksum = "92d43fe69e652f3df9bdc2b85b2854a0825b86e4fb76bc44d945137d053639ca" [[package]] name = "serde" -version = "1.0.197" +version = "1.0.199" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fb1c873e1b9b056a4dc4c0c198b24c3ffa059243875552b2bd0933b1aee4ce2" +checksum = "0c9f6e76df036c77cd94996771fb40db98187f096dd0b9af39c6c6e452ba966a" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.197" +version = "1.0.199" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b" +checksum = "11bd257a6541e141e42ca6d24ae26f7714887b47e89aa739099104c7e4d3b7fc" dependencies = [ "proc-macro2", "quote", @@ -1052,9 +1052,9 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.114" +version = "1.0.116" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c5f09b1bd632ef549eaa9f60a1f8de742bdbc698e6cee2095fc84dde5f549ae0" +checksum = "3e17db7126d17feb94eb3fad46bf1a96b034e8aacbc2e775fe81505f8b0b2813" dependencies = [ "itoa", "ryu", @@ -1260,6 +1260,8 @@ dependencies = [ "gettext-rs", "relm4", "relm4-icons", + "serde", + "serde_json", "tracing", "tracing-subscriber", ] diff --git a/Cargo.toml b/Cargo.toml index 19c3fb3..77b4106 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,3 +14,5 @@ tracing = "0.1" tracing-subscriber = "0.3" relm4 = { version = "0.8.1", features = ["libadwaita", "gnome_45"] } relm4-icons = { version = "0.8.1" } +serde = { version = "1.0.199", features = ["derive"] } +serde_json = "1.0.116" diff --git a/build-aux/org.kuchelmeister.ToolboxTuner.Devel.json b/build-aux/org.kuchelmeister.ToolboxTuner.Devel.json index 14a06c3..baf0556 100644 --- a/build-aux/org.kuchelmeister.ToolboxTuner.Devel.json +++ b/build-aux/org.kuchelmeister.ToolboxTuner.Devel.json @@ -9,13 +9,14 @@ ], "command": "toolbox-tuner", "finish-args": [ - "--share=ipc", + "--talk-name=org.freedesktop.Flatpak", "--socket=fallback-x11", "--socket=wayland", "--device=dri", - "--env=RUST_LOG=toolbox_tuner=debug", + "--env=RUST_LOG=toolbxtuner=debug", "--env=G_MESSAGES_DEBUG=none", - "--env=RUST_BACKTRACE=1" + "--env=RUST_BACKTRACE=1", + "--share=ipc" ], "build-options": { "append-path": "/usr/lib/sdk/rust-stable/bin:/usr/lib/sdk/llvm15/bin", diff --git a/src/app.rs b/src/app.rs index e58dfb0..a5a32e5 100644 --- a/src/app.rs +++ b/src/app.rs @@ -1,4 +1,5 @@ use crate::gtk::Align; +use crate::util::toolbox::ToolbxContainer; use relm4::factory::FactoryHashMap; use relm4::gtk::PolicyType; use relm4::RelmWidgetExt; @@ -39,6 +40,7 @@ relm4::new_action_group!(pub(super) WindowActionGroup, "win"); //relm4::new_stateless_action!(PreferencesAction, WindowActionGroup, "preferences"); relm4::new_stateless_action!(pub(super) ShortcutsAction, WindowActionGroup, "show-help-overlay"); relm4::new_stateless_action!(AboutAction, WindowActionGroup, "about"); +use crate::factories::container_list::ContainerInit; #[relm4::component(pub)] impl Component for App { @@ -130,20 +132,17 @@ impl Component for App { UnsupportedDialogOutput::CloseApplication => AppMsg::Quit, }); + let toolboxes = ToolbxContainer::get_toolboxes(); + let mut containers = FactoryHashMap::builder().launch_default().detach(); - containers.insert("123".to_string(), 2); - containers.insert("abc".to_string(), 3); - containers.insert("45435".to_string(), 3); - containers.insert("1dsal;k1;23".to_string(), 3); - containers.insert("afdsaf".to_string(), 3); - containers.insert("5344".to_string(), 3); - containers.insert("1242344".to_string(), 3); - containers.insert("1265464".to_string(), 3); - containers.insert( - "126222222222222222222222222222222222222222233333333333333333333333333333333325464" - .to_string(), - 3, - ); + toolboxes.iter().for_each(|toolbox| { + &containers.insert( + toolbox.id.clone(), + ContainerInit { + name: toolbox.name.clone(), + }, + ); + }); let model = Self { about_dialog, diff --git a/src/factories/container_list.rs b/src/factories/container_list.rs index a8533b4..d3555e6 100644 --- a/src/factories/container_list.rs +++ b/src/factories/container_list.rs @@ -10,17 +10,23 @@ use relm4_icons::icon_names; #[derive(Debug)] pub struct Container { hash: String, - value: u8, + value: String, } #[derive(Debug)] pub enum ContainerMsg { Start, + Stop, + OpenTerminal, +} + +pub struct ContainerInit { + pub name: String, } #[relm4::factory(pub)] impl FactoryComponent for Container { - type Init = u8; + type Init = ContainerInit; type Input = ContainerMsg; type Output = (); type CommandOutput = (); @@ -31,7 +37,8 @@ impl FactoryComponent for Container { view! { root = adw::ActionRow { #[watch] - set_title: format!{"{}: {}", self.hash, self.value.to_string()}.as_str(), + set_title: &self.value, + set_subtitle: &self.hash, add_prefix = >k::Box{ gtk::AspectFrame{ @@ -58,7 +65,7 @@ impl FactoryComponent for Container { set_margin_top: 10, set_margin_bottom: 10, set_css_classes: &["flat"], - connect_clicked => ContainerMsg::Start, + connect_clicked => ContainerMsg::OpenTerminal, }, }, }, @@ -68,15 +75,15 @@ impl FactoryComponent for Container { fn init_model(value: Self::Init, index: &Self::Index, _sender: FactorySender) -> Self { Self { hash: index.clone(), - value, + value: value.name.clone(), } } fn update(&mut self, msg: Self::Input, _sender: FactorySender) { match msg { - ContainerMsg::Start => { - self.value = self.value.wrapping_add(1); - } + ContainerMsg::Start => {} + ContainerMsg::Stop => {} + ContainerMsg::OpenTerminal => {} } } } diff --git a/src/main.rs b/src/main.rs index 1d0f8b9..7778180 100644 --- a/src/main.rs +++ b/src/main.rs @@ -2,6 +2,7 @@ mod app; mod config; mod factories; mod modals; +mod util; use crate::config::{APP_ID, GETTEXT_PACKAGE, LOCALEDIR, RESOURCES_FILE}; use gettextrs::{gettext, LocaleCategory}; diff --git a/src/util.rs b/src/util.rs new file mode 100644 index 0000000..b763831 --- /dev/null +++ b/src/util.rs @@ -0,0 +1 @@ +pub mod toolbox; diff --git a/src/util/toolbox.rs b/src/util/toolbox.rs new file mode 100644 index 0000000..bb0a3f3 --- /dev/null +++ b/src/util/toolbox.rs @@ -0,0 +1,427 @@ +use serde::{Deserialize, Serialize}; +use std::{fmt::Display, iter::zip, process::Command, str::FromStr, string::ParseError, sync::Arc}; + +#[derive(Debug, PartialEq)] +pub enum ToolbxError { + ParseStatusError(String), + JSONSerializationError(String), + CommandExecutionError(String), + CommandUnsuccessfulError(String), +} + +impl std::error::Error for ToolbxError {} + +impl Display for ToolbxError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + ToolbxError::ParseStatusError(parse_error) => write!(f, "{}", parse_error), + ToolbxError::CommandExecutionError(command_exec_error) => { + write!(f, "{}", command_exec_error) + } + ToolbxError::JSONSerializationError(msg) => { + write!(f, "{}", msg) + } + ToolbxError::CommandUnsuccessfulError(command_unsuc_error) => { + write!(f, "{}", command_unsuc_error) + } + } + } +} + +#[derive(Debug, PartialEq, Clone)] +pub enum ToolbxStatus { + Running, + Configured, + Created, + Exited, +} + +impl Default for ToolbxStatus { + fn default() -> Self { + ToolbxStatus::Configured + } +} + +impl FromStr for ToolbxStatus { + type Err = ToolbxError; + + fn from_str(s: &str) -> Result { + match s { + "running" => Ok(ToolbxStatus::Running), + "configured" => Ok(ToolbxStatus::Configured), + "created" => Ok(ToolbxStatus::Created), + "exited" => Ok(ToolbxStatus::Exited), + s => Err(ToolbxError::ParseStatusError(format!( + "'{}' is not a valid toolbx status.", + s + ))), + } + } +} + +#[derive(Debug, PartialEq, Default, Clone)] +pub struct ToolbxContainer { + pub id: String, + pub name: String, + pub created: String, + pub status: ToolbxStatus, + pub image: String, +} + +pub type PodmanInspectArray = Vec; + +#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct PodmanInspectInfo { + #[serde(rename = "Id")] + pub id: String, + #[serde(rename = "Created")] + pub created: String, + #[serde(rename = "State")] + pub state: PodManInspectState, + #[serde(rename = "Image")] + pub image: String, + #[serde(rename = "ImageName")] + pub image_name: String, + #[serde(rename = "Name")] + pub name: String, +} + +#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct PodManInspectState { + #[serde(rename = "Status")] + pub status: String, +} + +pub enum ToolboxCreateParameter { + None, + Distro(String), + Image(String), + Release(String), +} + +impl ToolbxContainer { + pub fn new(name: String) -> ToolbxContainer { + ToolbxContainer { + name: name, + ..Default::default() + } + } + + pub fn create(name: String, parameter: ToolboxCreateParameter) { + todo!("Implement actual functionality to create toolbox via commandline") + } + + pub fn get_toolboxes() -> Vec { + let output = run_cmd_toolbx_list_containers(); + println!("{}", output); + parse_cmd_list_containers(output.as_str()) + } + + fn parse_status(output: &str) -> Result { + let result: Result = serde_json::from_str(output); + match result { + Ok(inspect_vec) => match inspect_vec.first() { + Some(info) => Ok(info.clone()), + None => Err(ToolbxError::JSONSerializationError( + "Inspect command returned empty vector.".to_string(), + )), + }, + Err(e) => Err(ToolbxError::JSONSerializationError(e.to_string())), + } + } + + pub fn update_status(&mut self) -> Result<(), ToolbxError> { + let output = Command::new("flatpak-spawn") + .arg("--host") + .arg("podman") + .arg("container") + .arg("inspect") + .arg(self.name.clone()) + .output() + .expect("Failed to execute command"); + + let output = String::from_utf8_lossy(&output.stdout).to_string(); + let inspect_result = ToolbxContainer::parse_status(output.as_str())?; + self.status = ToolbxStatus::from_str(inspect_result.state.status.as_str())?; + Ok(()) + } + + pub fn stop(&mut self) -> Result<(), ToolbxError> { + let output = Command::new("flatpak-spawn") + .arg("--host") //Command::new("podman") + .arg("podman") + .arg("stop") + .arg(self.name.clone()) + .output(); + + if output.is_err() { + return Err(ToolbxError::CommandExecutionError( + output.unwrap_err().to_string(), + )); + } + let output = output.unwrap(); + + // Success: Output { status: ExitStatus(unix_wait_status(0)), stdout: "tbx_name\n", stderr: "" } + //Fail: + // Output { + // status: ExitStatus(unix_wait_status(32000)), + // stdout: "", + // stderr: "Error: no container with name or ID \"tbx_name\" found: no such container\n" + // } + + if output.status.code() == Some(0) { + self.status = ToolbxStatus::Exited; + Ok(()) + } else { + Err(ToolbxError::CommandUnsuccessfulError( + String::from_utf8_lossy(&output.stderr).into_owned(), + )) + } + } + + pub fn start(&mut self) -> Result<(), ToolbxError> { + let output = Command::new("flatpak-spawn") + .arg("--host") //Command::new("podman") + .arg("podman") + .arg("start") + .arg(self.name.clone()) + .output(); + + if output.is_err() { + return Err(ToolbxError::CommandExecutionError( + output.unwrap_err().to_string(), + )); + } + let output = output.unwrap(); + + // Success: status: Output { ExitStatus(unix_wait_status(0)), stdout: "tbx_name\n", stderr: "" } + // Fail: status: + // Output { + // status: ExitStatus(unix_wait_status(32000)), + // stdout: "", + // stderr: "Error: no container with name or ID \"tbx_name\" found: no such container\n" + // } + + if output.status.code() == Some(0) { + self.status = ToolbxStatus::Running; + Ok(()) + } else { + Err(ToolbxError::CommandUnsuccessfulError( + String::from_utf8_lossy(&output.stderr).into_owned(), + )) + } + } +} + +#[test] +fn test_start_1non_existing_container() { + // TODO: create container that exists based on simple image + // run command + // delete container + //let tbx = ToolbxContainer{created: "".to_string(), id: "".to_string(), name: "latex".to_string(), image: "".to_string(), status: ToolbxStatus::Exited}; + + //tbx.stop(); +} + +#[test] +fn test_inspect_parsing() { + let podman_inspect = concat!( + "[{", + "\"Id\": \"ae05203091ab4cdf047a9aeba6af8a7bed8105f7f59d09a35d2b64c837ecac0d\",", + "\"Created\": \"2021-12-10T20:51:43.140418098+01:00\",", + "\"State\": {", + "\"Status\": \"running\"", + "},", + "\"Image\": \"ab8bc106d4a710a7a27c538762864610467b3559f80b413d30e0a1bfcfe272a5\",", + "\"ImageName\": \"registry.fedoraproject.org/fedora-toolbox:35\",", + "\"Name\": \"rust\"", + "}]" + ); + let inspect_info = ToolbxContainer::parse_status(podman_inspect).unwrap(); + assert_eq!("running", inspect_info.state.status); +} + +#[test] +fn test_start_non_existing_container() { + let name = "zy2lM6BdZoTnKHaVPkUJ".to_string(); + let mut tbx = ToolbxContainer { + created: "".to_string(), + id: "".to_string(), + name: name.clone(), + image: "".to_string(), + status: ToolbxStatus::Exited, + }; + + assert_eq!( + Err(ToolbxError::CommandUnsuccessfulError(format!( + "Error: no container with name or ID \"{}\" found: no such container\n", + name + ))), + tbx.start() + ); +} + +pub fn run_cmd_toolbx_list_containers() -> String { + let output = Command::new("flatpak-spawn") + .arg("--host") + .arg("toolbox") + .arg("list") + .arg("--containers") + .output() + .expect("Failed to execute command"); + + println!("{:?}", String::from_utf8_lossy(&output.stdout).to_string()); + + String::from_utf8_lossy(&output.stdout).to_string() +} + +#[test] +#[ignore] +fn test_cmd_list_containers() { + // This requires toolbx to be installed + let toolbox_cmd_container_header = + "CONTAINER ID CONTAINER NAME CREATED STATUS IMAGE NAME"; + assert!(run_cmd_toolbx_list_containers().starts_with(toolbox_cmd_container_header)); +} + +fn tokenize_line_list_containers(line: &str) -> Vec { + let mut tokens = Vec::::new(); + let mut current_token = Vec::::new(); + + let mut whitespace_section = false; + + let mut iter = line.chars().peekable(); + while let Some(&c) = iter.peek() { + match (whitespace_section, c) { + (false, ' ') => { + iter.next(); + if Some(' ') == iter.peek().map(|x| x.clone()) { + whitespace_section = true; + } else { + current_token.push(c); + } + } + (true, ' ') => { + iter.next(); + } + (true, c) => { + whitespace_section = false; + tokens.push(current_token.into_iter().collect()); + current_token = Vec::new(); + current_token.push(c); + iter.next(); + } + (false, c) => { + current_token.push(c); + iter.next(); + } + } + } + tokens.push(current_token.into_iter().collect()); + + tokens +} + +#[test] +fn test_tokenize_line_list_containers() { + let toolbox_cmd_container_header = "ae05203091ab rust 4 months ago \ + running registry.fedoraproject.org/fedora-toolbox:35"; + + let target = vec![ + "ae05203091ab", + "rust", + "4 months ago", + "running", + "registry.fedoraproject.org/fedora-toolbox:35", + ]; + let result = tokenize_line_list_containers(toolbox_cmd_container_header); + assert_eq!(target, result); +} + +fn parse_line_list_containers(line: &str) -> Result { + let tokens = tokenize_line_list_containers(line); + if tokens.len() != 5 { + panic! {"Expected 5 tokens found {} in {:?}", tokens.len(), tokens}; + } + Ok(ToolbxContainer { + id: tokens[0].clone(), + name: tokens[1].clone(), + created: tokens[2].clone(), + status: ToolbxStatus::from_str(&tokens[3])?, + image: tokens[4].clone(), + }) +} + +#[test] +fn test_parse_line_list_containers() { + let toolbox_cmd_container_header = "ae05203091ab rust 4 months ago \ + running registry.fedoraproject.org/fedora-toolbox:35"; + + let target = ToolbxContainer { + id: "ae05203091ab".to_string(), + name: "rust".to_string(), + created: "4 months ago".to_string(), + status: ToolbxStatus::Running, + image: "registry.fedoraproject.org/fedora-toolbox:35".to_string(), + }; + let result = parse_line_list_containers(toolbox_cmd_container_header); + assert_eq!(target, result.unwrap()); +} + +fn parse_cmd_list_containers(output: &str) -> Vec { + let lines = output.trim().split("\n").skip(1); + println!("{:?}", lines); + lines.map(parse_line_list_containers).flatten().collect() +} + +#[test] +fn test_parse_cmd_list_containers() { + // This requires toolbx to be installed + let toolbox_cmd_container_header = concat!( + "CONTAINER ID CONTAINER NAME CREATED STATUS IMAGE NAME\n", + "cee1002b5f0b fedora-toolbox-35 2 months ago exited registry.fedoraproject.org/fedora-toolbox:35\n", + "9b611313bf65 latex 4 months ago configured registry.fedoraproject.org/fedora-toolbox:35\n", + "1235203091ab website 4 months ago created registry.fedoraproject.org/fedora-toolbox:35\n", + "ae05203091ab rust 4 months ago running registry.fedoraproject.org/fedora-toolbox:35\n" + ); + + let desired_result = vec![ + ToolbxContainer { + id: "cee1002b5f0b".to_string(), + name: "fedora-toolbox-35".to_string(), + created: "2 months ago".to_string(), + status: ToolbxStatus::Exited, + image: "registry.fedoraproject.org/fedora-toolbox:35".to_string(), + }, + ToolbxContainer { + id: "9b611313bf65".to_string(), + name: "latex".to_string(), + created: "4 months ago".to_string(), + status: ToolbxStatus::Configured, + image: "registry.fedoraproject.org/fedora-toolbox:35".to_string(), + }, + ToolbxContainer { + id: "1235203091ab".to_string(), + name: "website".to_string(), + created: "4 months ago".to_string(), + status: ToolbxStatus::Created, + image: "registry.fedoraproject.org/fedora-toolbox:35".to_string(), + }, + ToolbxContainer { + id: "ae05203091ab".to_string(), + name: "rust".to_string(), + created: "4 months ago".to_string(), + status: ToolbxStatus::Running, + image: "registry.fedoraproject.org/fedora-toolbox:35".to_string(), + }, + ]; + + for (result, desired) in zip( + parse_cmd_list_containers(toolbox_cmd_container_header).iter(), + desired_result.iter(), + ) { + assert_eq!(result, desired) + } +}