...

doctree/src/collection.rs

@@ -424,9 +424,8 @@ impl Collection {
         info.insert("path".to_string(), self.path.to_string_lossy().to_string());
         info
     }
-}
 
-    /// Exports files and images from the collection to IPFS, encrypts them, and generates a CSV manifest.
+    /// Exports files and images from the collection to IPFS synchronously, encrypting them, and generating a CSV manifest.
     ///
     /// # Arguments
     ///
@@ -435,8 +434,16 @@ impl Collection {
     /// # Returns
     ///
     /// Ok(()) on success or an error.
-impl Collection {
-    /// Exports files and images from the collection to IPFS, encrypts them, and generates a CSV manifest.
+    pub fn export_to_ipfs(&self, output_csv_path: &Path) -> Result<()> {
+        // Create a new tokio runtime and block on the async export function
+        tokio::runtime::Runtime::new()?.block_on(async {
+            self.export_to_ipfs_async(output_csv_path).await
+        })?;
+
+        Ok(())
+    }
+
+    /// Exports files and images from the collection to IPFS asynchronously, encrypts them, and generates a CSV manifest.
     ///
     /// # Arguments
     ///
@@ -445,7 +452,7 @@ impl Collection {
     /// # Returns
     ///
     /// Ok(()) on success or an error.
-    pub async fn export_to_ipfs(&self, output_csv_path: &Path) -> Result<()> {
+    pub async fn export_to_ipfs_async(&self, output_csv_path: &Path) -> Result<()> {
         use blake3::Hasher;
         // use chacha20poly1305::{ChaCha20Poly1305, Aead};
         use ipfs_api::IpfsClient;

doctree/src/doctree.rs

@@ -1,3 +1,4 @@
+
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
@@ -551,7 +552,7 @@ impl DocTree {
         for (name, collection) in &self.collections {
             let csv_file_path = output_dir.join(format!("{}.csv", name));
             println!("DEBUG: Exporting collection '{}' to IPFS and generating CSV at {:?}", name, csv_file_path);
-            if let Err(e) = collection.export_to_ipfs(&csv_file_path).await {
+            if let Err(e) = collection.export_to_ipfs(&csv_file_path) {
                 eprintln!("Error exporting collection '{}': {}", name, e);
                 // Continue with the next collection
             }
@@ -559,6 +560,26 @@ impl DocTree {
 
         Ok(())
     }
+
+    /// Exports a specific collection to IPFS synchronously, encrypting its files and generating a CSV manifest.
+    ///
+    /// # Arguments
+    ///
+    /// * `collection_name` - The name of the collection to export.
+    /// * `output_csv_path` - The path to save the output CSV file.
+    ///
+    /// # Returns
+    ///
+    /// Ok(()) on success or an error.
+    pub fn export_collection_to_ipfs(&self, collection_name: &str, output_csv_path: &Path) -> Result<()> {
+        // Get the collection
+        let collection = self.get_collection(collection_name)?;
+
+        // Create a new tokio runtime and block on the async export function
+        collection.export_to_ipfs(output_csv_path);
+
+        Ok(())
+    }
 }
 
 impl DocTreeBuilder {

doctreecmd/src/main.rs

@@ -69,6 +69,13 @@ fn main() -> Result<()> {
                 .about("Delete all collections from Redis")
                 .arg(Arg::with_name("doctree").long("doctree").takes_value(true).help("Name of the doctree (default: 'default')")),
         )
+        .subcommand(
+            SubCommand::with_name("export_to_ipfs")
+                .about("Export a collection to IPFS")
+                .arg(Arg::with_name("collection").required(true).help("Name of the collection"))
+                .arg(Arg::with_name("output").required(true).help("Output directory for IPFS export"))
+                .arg(Arg::with_name("doctree").long("doctree").takes_value(true).help("Name of the doctree (default: 'default')")),
+        )
         .get_matches();
 
     // Check if debug mode is enabled
@@ -342,6 +349,43 @@ fn main() -> Result<()> {
         println!("Deleting collection '{}' from Redis in doctree '{}'...", collection, doctree_name);
         doctree.delete_collection(collection)?;
         println!("Collection '{}' deleted successfully", collection);
+    } else if let Some(matches) = matches.subcommand_matches("export_to_ipfs") {
+        let collection_name = matches.value_of("collection").unwrap();
+        let output_path = matches.value_of("output").unwrap();
+        let doctree_name = matches.value_of("doctree").unwrap_or("default");
+
+        if debug_mode {
+            println!("DEBUG: Exporting collection '{}' from doctree '{}' to IPFS output path '{}'",
+                     collection_name, doctree_name, output_path);
+        }
+
+        // Create a storage with the specified doctree name
+        let storage = RedisStorage::new("redis://localhost:6379")?;
+        storage.set_doctree_name(doctree_name);
+        storage.set_debug(debug_mode);
+
+        if debug_mode {
+            println!("DEBUG: Connected to Redis storage");
+        }
+
+        // Create a DocTree with the specified doctree name
+        let mut doctree = DocTree::builder()
+            .with_storage(storage)
+            .with_doctree_name(doctree_name)
+            .build()?;
+
+        // Load collections from Redis
+        doctree.load_collections_from_redis()?;
+
+        // Get the collection
+        let collection = doctree.get_collection(collection_name)?;
+
+        // Call the synchronous export_collection_to_ipfs_sync function from the doctree crate
+        let output_path = Path::new(output_path);
+        doctree.export_collection_to_ipfs(collection_name, output_path)?;
+
+        println!("Successfully exported collection '{}' to IPFS and generated metadata CSV at {:?}.", collection_name, output_path.join(format!("{}.csv", collection_name)));
+
     } else if let Some(matches) = matches.subcommand_matches("reset") {
         let doctree_name = matches.value_of("doctree").unwrap_or("default");