feat: async upload of medias

src/config.rs

@@ -8,7 +8,7 @@ pub struct Config {
     pub twitter: TwitterConfig,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Deserialize, Clone)]
 pub struct TwitterConfig {
     pub consumer_key: String,
     pub consumer_secret: String,

src/lib.rs

@@ -20,8 +20,11 @@ mod twitter;
 #[allow(unused_imports)]
 use twitter::{post_tweet, upload_chunk_media, upload_simple_media};
 
+use futures::{stream, StreamExt};
+use log::{error, warn};
 use megalodon::entities::attachment::AttachmentType;
 use rusqlite::Connection;
+use std::error::Error;
 
 #[tokio::main]
 pub async fn run(config: &Config) {
@@ -40,42 +43,45 @@ pub async fn run(config: &Config) {
         let Ok(tweet_content) = strip_everything(&toot.content, &toot.tags) else {
             continue; // skip in case we can’t strip something
         };
+
         let mut medias: Vec<u64> = vec![];
 
         // if we wanted to cut toot in half, now would be the right time to do so
 
-        // treats media
-        for media in toot.media_attachments {
-            let id = match media.r#type {
-                AttachmentType::Image => {
-                    let Ok(id) =
-                        upload_simple_media(&config.twitter, &media.url, &media.description).await
-                    else {
-                        continue;
-                    };
-                    id
-                }
-                AttachmentType::Gifv => {
-                    let Ok(id) = upload_chunk_media(&config.twitter, &media.url, "tweet_gif").await
-                    else {
-                        continue;
-                    };
-                    id
-                }
-                AttachmentType::Video => {
-                    let Ok(id) =
-                        upload_chunk_media(&config.twitter, &media.url, "tweet_video").await
-                    else {
-                        continue;
-                    };
-                    id
-                }
-                _ => {
-                    continue;
-                }
-            };
+        let media_attachments = toot.media_attachments.clone();
+        let mut stream = stream::iter(media_attachments)
+            .map(|media| {
+                let twitter_config = config.twitter.clone();
+                tokio::task::spawn(async move {
+                    match media.r#type {
+                        AttachmentType::Image => {
+                            upload_simple_media(&twitter_config, &media.url, &media.description)
+                                .await
+                        }
+                        AttachmentType::Gifv => {
+                            upload_chunk_media(&twitter_config, &media.url, "tweet_gif").await
+                        }
+                        AttachmentType::Video => {
+                            upload_chunk_media(&twitter_config, &media.url, "tweet_video").await
+                        }
+                        _ => Err::<u64, Box<dyn Error + Send + Sync>>(
+                            OolatoocsError::new(&format!(
+                                "Cannot treat this type of media: {}",
+                                &media.url
+                            ))
+                            .into(),
+                        ),
+                    }
+                })
+            })
+            .buffered(4);
 
-            medias.push(id);
+        while let Some(result) = stream.next().await {
+            match result {
+                Ok(Ok(v)) => medias.push(v),
+                Ok(Err(e)) => warn!("Cannot treat media: {}", e),
+                Err(e) => error!("Something went wrong when joining the main thread: {}", e),
+            }
         }
 
         // threads if necessary

src/twitter.rs

@@ -104,7 +104,7 @@ pub async fn upload_simple_media(
     config: &TwitterConfig,
     u: &str,
     d: &Option<String>,
-) -> Result<u64, Box<dyn Error>> {
+) -> Result<u64, Box<dyn Error + Send + Sync>> {
     // initiate request parameters
     let empty_request = EmptyRequest {}; // Why? Because fuck you, that’s why!
     let token = get_token(config);
@@ -152,7 +152,11 @@ pub async fn upload_simple_media(
 }
 
 /// This function updates the metadata given the current media_id and token
-async fn metadata_create(config: &TwitterConfig, id: u64, m: &str) -> Result<(), Box<dyn Error>> {
+async fn metadata_create(
+    config: &TwitterConfig,
+    id: u64,
+    m: &str,
+) -> Result<(), Box<dyn Error + Send + Sync>> {
     let token = get_token(config);
     let empty_request = EmptyRequest {};
 
@@ -191,7 +195,7 @@ pub async fn upload_chunk_media(
     config: &TwitterConfig,
     u: &str,
     t: &str,
-) -> Result<u64, Box<dyn Error>> {
+) -> Result<u64, Box<dyn Error + Send + Sync>> {
     let empty_request = EmptyRequest {};
     let token = get_token(config);