Add support for exporting binaries

Author: ranfdev

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "distroshelf"
 version = "1.0.2"
-edition = "2021"
+edition = "2024"
 
 [dependencies]
 gettext-rs = { version = "0.7", features = ["gettext-system"] }

src/container.rs

@@ -40,6 +40,8 @@ mod imp {
         pub distro: RefCell<Option<KnownDistro>>,
         #[property(get, set)]
         pub apps: RefCell<RemoteResource>,
+        #[property(get, set)]
+        pub binaries: RefCell<RemoteResource>,
     }
 
     #[derived_properties]
@@ -79,7 +81,6 @@ impl Container {
 
         let this_clone = this.clone();
         let loader = move |apps_list: Option<&gio::ListStore>| {
-            dbg!(apps_list);
             let this = this_clone.clone();
             let mut apps_list = apps_list
                 .cloned()
@@ -101,6 +102,29 @@ impl Container {
         };
         this.set_apps(RemoteResource::new::<gio::ListStore, _>(loader));
 
+        let this_clone = this.clone();
+        let binaries_loader = move |binaries_list: Option<&gio::ListStore>| {
+            let this = this_clone.clone();
+            let mut binaries_list = binaries_list
+                .cloned()
+                .unwrap_or_else(gio::ListStore::new::<BoxedAnyObject>);
+            async move {
+                let binaries = this
+                    .root_store()
+                    .distrobox()
+                    .get_exported_binaries(&this.name())
+                    .await?;
+
+                binaries_list.remove_all();
+                binaries_list.extend(binaries.into_iter().map(BoxedAnyObject::new));
+
+                // Listing the binaries starts the container, we need to update its status
+                this.root_store().load_containers();
+                Ok(binaries_list)
+            }
+        };
+        this.set_binaries(RemoteResource::new::<gio::ListStore, _>(binaries_loader));
+
         this
     }
 
@@ -185,6 +209,32 @@ impl Container {
                 Ok(())
             });
     }
+    pub fn export_binary(&self, binary_path: &str) -> DistroboxTask {
+        let this = self.clone();
+        let binary_path = binary_path.to_string();
+        self.root_store()
+            .create_task(&self.name(), "export-binary", move |_task| async move {
+                this.root_store()
+                    .distrobox()
+                    .export_binary(&this.name(), &binary_path)
+                    .await?;
+                this.binaries().reload();
+                Ok(())
+            })
+    }
+    pub fn unexport_binary(&self, binary_path: &str) {
+        let this = self.clone();
+        let binary_path = binary_path.to_string();
+        self.root_store()
+            .create_task(&self.name(), "unexport-binary", move |_task| async move {
+                this.root_store()
+                    .distrobox()
+                    .unexport_binary(&this.name(), &binary_path)
+                    .await?;
+                this.binaries().reload();
+                Ok(())
+            });
+    }
     pub fn clone_to(&self, target_name: &str) {
         let this = self.clone();
         let target_name_clone = target_name.to_string();

src/dialogs/create_distrobox_dialog.rs

@@ -500,7 +500,7 @@ impl CreateDistroboxDialog {
         let imp = self.imp();
         imp.name_row.remove_css_class("error");
         imp.name_row.set_tooltip_text(None);
-        if let Err(ref e) = res {
+        if let Err(e) = res {
             error!(error = %e, "CreateDistroboxDialog: update_errors");
         }
         match res {

src/dialogs/exportable_apps_dialog.rs

@@ -4,7 +4,8 @@ use gtk::glib::{clone, BoxedAnyObject};
 use gtk::{gio, glib, pango};
 
 use crate::container::Container;
-use crate::distrobox::ExportableApp;
+use crate::distrobox::{ExportableApp, ExportableBinary};
+use crate::gtk_utils::reaction;
 
 use std::cell::RefCell;
 
@@ -20,19 +21,22 @@ mod imp {
         #[property(get, set)]
         pub container: RefCell<Container>,
         pub dialog: adw::Dialog,
+        pub toast_overlay: adw::ToastOverlay,
         pub toolbar_view: adw::ToolbarView,
         pub content: gtk::Box,
         pub scrolled_window: gtk::ScrolledWindow,
         pub stack: gtk::Stack,
         pub error_label: gtk::Label,
         pub list_box: gtk::ListBox,
+        pub binaries_list_box: gtk::ListBox,
+        pub binary_name_entry: adw::EntryRow,
     }
 
     #[derived_properties]
     impl ObjectImpl for ExportableAppsDialog {
         fn constructed(&self) {
             let obj = self.obj();
-            obj.set_title("Exportable Apps");
+            obj.set_title("Manage Exports");
             obj.set_content_width(360);
             obj.set_content_height(640);
 
@@ -52,9 +56,9 @@ mod imp {
             self.stack.add_named(&self.error_label, Some("error"));
 
             let loading_page = adw::StatusPage::new();
-            loading_page.set_title("Loading App List");
+            loading_page.set_title("Loading Exports");
             loading_page.set_description(Some(
-                "Please wait while we load the list of exportable apps. This may take some time if the distrobox wasn't running",
+                "Please wait while we load the list of exportable apps and binaries. This may take some time if the distrobox wasn't running",
             ));
             loading_page.set_child(Some(&adw::Spinner::new()));
             self.stack.add_named(&loading_page, Some("loading"));
@@ -68,16 +72,41 @@ mod imp {
             export_apps_group.set_margin_bottom(12);
             export_apps_group.set_title("Exportable Apps");
             export_apps_group.add(&self.list_box);
-            self.stack.add_named(&export_apps_group, Some("apps"));
+
+            // Setup binary export input
+            self.binary_name_entry.set_title("Export New Binary");
+            self.binary_name_entry.set_show_apply_button(true);
+            self.binary_name_entry
+                .add_css_class("add-binary-entry-row");
+
+            self.binaries_list_box.add_css_class("boxed-list");
+            self.binaries_list_box.set_selection_mode(gtk::SelectionMode::None);
+            self.binaries_list_box.set_margin_top(12);
+            
+            let export_binaries_group = adw::PreferencesGroup::new();
+            export_binaries_group.set_margin_start(12);
+            export_binaries_group.set_margin_end(12);
+            export_binaries_group.set_margin_top(0);
+            export_binaries_group.set_margin_bottom(12);
+            export_binaries_group.set_title("Exported Binaries");
+            export_binaries_group.add(&self.binary_name_entry);
+            export_binaries_group.add(&self.binaries_list_box);
+
+            let content_box = gtk::Box::new(gtk::Orientation::Vertical, 0);
+            content_box.append(&export_apps_group);
+            content_box.append(&export_binaries_group);
+            self.stack.add_named(&content_box, Some("apps"));
 
             let empty_page = adw::StatusPage::new();
-            empty_page.set_title("No Exportable Apps");
+            empty_page.set_title("No Exportable Items");
+            empty_page.set_description(Some("No applications or binaries found in this container"));
 
             self.stack.add_named(&empty_page, Some("empty"));
 
             self.content.append(&self.scrolled_window);
             self.toolbar_view.set_content(Some(&self.content));
-            self.obj().set_child(Some(&self.toolbar_view));
+            self.toast_overlay.set_child(Some(&self.toolbar_view));
+            self.obj().set_child(Some(&self.toast_overlay));
         }
     }
 
@@ -104,6 +133,22 @@ mod imp {
                     this.container().unexport(file_path);
                 },
             );
+            klass.install_action(
+                "dialog.export-binary",
+                Some(VariantTy::STRING),
+                |this, _action, target| {
+                    let binary_path = target.unwrap().str().unwrap();
+                    this.container().export_binary(binary_path);
+                },
+            );
+            klass.install_action(
+                "dialog.unexport-binary",
+                Some(VariantTy::STRING),
+                |this, _action, target| {
+                    let binary_path = target.unwrap().str().unwrap();
+                    this.container().unexport_binary(binary_path);
+                },
+            );
         }
     }
 
@@ -121,43 +166,119 @@ impl ExportableAppsDialog {
             .property("container", container)
             .build();
 
+        let apps = this.container().apps();
+        let binaries = this.container().binaries();
+
+        let is_empty = move || -> bool {
+            let n_apps = apps.data::<gio::ListStore>().map(|s| s.n_items()).unwrap_or(0);
+            let n_binaries = binaries.data::<gio::ListStore>().map(|s| s.n_items()).unwrap_or(0);
+            n_apps == 0 && n_binaries == 0
+        };
+        
         let this_clone = this.clone();
-        container.apps().connect_loading_notify(move |resource| {
-            if resource.loading() {
-                this_clone.imp().stack.set_visible_child_name("loading");
-            }
-        });
-        let this_clone = this.clone();
-        container.apps().connect_error_notify(move |resource| {
-            if let Some(err) = resource.error() {
-                this_clone.imp().error_label.set_label(&err);
-                this_clone.imp().stack.set_visible_child_name("error");
+        let apps = this.container().apps();
+        let binaries = this.container().binaries();
+        reaction! {
+            (apps.error(), binaries.error()),
+            move |(e1, e2): (Option<String>, Option<String>)| {
+                if let Some(err) = e1.or(e2) {
+                    this_clone.imp().error_label.set_label(&err);
+                    this_clone.imp().stack.set_visible_child_name("error");
+                }
             }
-        });
+        };
+        
         let this_clone = this.clone();
-        container.apps().connect_data_changed(move |resource| {
-            let apps = resource.data::<gio::ListStore>().unwrap();
-
-            if apps.n_items() == 0 {
-                this_clone.imp().stack.set_visible_child_name("empty");
-                return;
-            }
+        let apps = this.container().apps();
+        let render_apps = move || {
+            let apps = apps.data::<gio::ListStore>();
 
             this_clone.imp().stack.set_visible_child_name("apps");
-
             let this = this_clone.clone();
             this_clone
                 .imp()
                 .list_box
-                .bind_model(Some(&apps), move |obj| {
+                .bind_model(apps.as_ref(), move |obj| {
                     let app = obj
                         .downcast_ref::<BoxedAnyObject>()
                         .map(|obj| obj.borrow::<ExportableApp>())
                         .unwrap();
                     this.build_row(&app).upcast()
                 });
-        });
+                
+        };
+        
+        let this_clone = this.clone();
+        let binaries = this.container().binaries();
+        let render_binaries = move || {
+            let binaries = binaries.data::<gio::ListStore>();
+
+            this_clone.imp().stack.set_visible_child_name("apps");
+            let this = this_clone.clone();
+            this_clone
+                .imp()
+                .binaries_list_box
+                .bind_model(binaries.as_ref(), move |obj| {
+                    let binary = obj
+                        .downcast_ref::<BoxedAnyObject>()
+                        .map(|obj| obj.borrow::<ExportableBinary>())
+                        .unwrap();
+                    this.build_binary_row(&binary).upcast()
+                });
+        };
+
+        let this_clone = this.clone();
+        let apps = this.container().apps();
+        let binaries = this.container().binaries();
+        reaction! {
+            (apps.loading(), binaries.loading()),
+            move |(b1, b2): (bool, bool)| {
+                if b1 || b2 {
+                    this_clone.imp().stack.set_visible_child_name("loading");
+                } else if is_empty() {
+                    this_clone.imp().stack.set_visible_child_name("empty");
+                } else {
+                    render_apps();
+                    render_binaries();
+                }
+            }
+        };
+
+        
+        // Connect the binary name entry apply signal
+        let this_clone = this.clone();
+        this.imp()
+            .binary_name_entry
+            .connect_apply(move |entry| {
+                let binary_name = entry.text().to_string();
+                if !binary_name.is_empty() {
+                    let task = this_clone.container().export_binary(&binary_name);
+                    entry.set_text("");
+                    
+                    // Monitor task status to show error toasts
+                    let this = this_clone.clone();
+                    let binary_name_clone = binary_name.clone();
+                    reaction!(task.status(), move |status: String| {
+                        match status.as_str() {
+                            "failed" => {
+                                let error_ref = task.error();
+                                let error_msg = if let Some(err) = error_ref.as_ref() {
+                                    format!("Failed to export '{}': {}", binary_name_clone, err)
+                                } else {
+                                    format!("Failed to export '{}'", binary_name_clone)
+                                };
+                                let toast = adw::Toast::new(&error_msg);
+                                toast.set_timeout(5);
+                                this.imp().toast_overlay.add_toast(toast);
+                            }
+                            _ => {}
+                        }
+                    });
+                }
+            });
+
         container.apps().reload();
+        container.binaries().reload();
 
         this
     }
@@ -212,4 +333,37 @@ impl ExportableAppsDialog {
 
         row
     }
+    
+    pub fn build_binary_row(&self, binary: &ExportableBinary) -> adw::ActionRow {
+        // Create the action row
+        let row = adw::ActionRow::new();
+        row.set_title(&binary.name);
+        row.set_subtitle(&binary.source_path);
+
+        // Create the menu button
+        let menu_button = gtk::MenuButton::new();
+        menu_button.set_icon_name("view-more-symbolic");
+        menu_button.set_valign(gtk::Align::Center);
+        menu_button.add_css_class("flat");
+
+        // Create the menu model - only show unexport since we're only showing exported binaries
+        let menu_model = gio::Menu::new();
+        let unexport_action = gio::MenuItem::new(
+            Some("Unexport Binary"),
+            Some(&format!(
+                "dialog.unexport-binary(\"{}\")",
+                binary.source_path
+            )),
+        );
+        menu_model.append_item(&unexport_action);
+
+        // Set up the popover menu
+        let popover = gtk::PopoverMenu::from_model(Some(&menu_model));
+        menu_button.set_popover(Some(&popover));
+
+        // Add the menu button to the action row
+        row.add_suffix(&menu_button);
+
+        row
+    }
 }