fix: Fixed abort on error during requesting an update (#1181)

* fix: Fixed abort on error during requesting an update

* fix: Continue on error in pipeline

Author: SamTV12345

src/command_line_runner.rs

@@ -67,8 +67,8 @@ pub async fn start_command_line(mut args: Args) -> Result<(), CustomError> {
                             let podcast = Podcast::get_podcast_by_rss_feed(replaced_feed, conn)
                                 .expect("Error getting podcast");
 
-                            PodcastEpisodeService::insert_podcast_episodes(podcast.clone())?;
-                            PodcastService::schedule_episode_download(podcast)
+                            PodcastEpisodeService::insert_podcast_episodes(&podcast)?;
+                            PodcastService::schedule_episode_download(&podcast)
                         }
                         None => {
                             println!("Please provide a podcast rss feed url");
@@ -81,8 +81,8 @@ pub async fn start_command_line(mut args: Args) -> Result<(), CustomError> {
                     for podcast in podcasts {
                         println!("Refreshing podcast {}", podcast.name);
 
-                        PodcastEpisodeService::insert_podcast_episodes(podcast.clone())?;
-                        PodcastService::schedule_episode_download(podcast)?;
+                        PodcastEpisodeService::insert_podcast_episodes(&podcast)?;
+                        PodcastService::schedule_episode_download(&podcast)?;
                     }
                     Ok(())
                 }

src/commands/startup.rs

@@ -66,8 +66,18 @@ pub fn run_poll() -> Result<(), CustomError> {
     for podcast in podcats_result {
         if podcast.active {
             let podcast_clone = podcast.clone();
-            PodcastEpisodeService::insert_podcast_episodes(podcast)?;
-            PodcastService::schedule_episode_download(podcast_clone)?;
+            let insert_result = PodcastEpisodeService::insert_podcast_episodes(&podcast);
+            if let Err(e) = insert_result {
+                log::error!("Could not insert new podcast episodes for podcast: {} with cause {}",
+                    &podcast.name, e);
+                continue;
+            }
+            let schedule = PodcastService::schedule_episode_download(&podcast_clone);
+            if let Err(e) = schedule {
+                log::error!("Could not schedule episode download for podcast: {} with cause {}",
+                    &podcast.name, e);
+                continue;
+            }
         }
     }
     Ok(())
@@ -321,7 +331,7 @@ pub fn handle_config_for_server_startup() -> Router {
                         info!("Polling for new episodes");
                         match run_poll() {
                             Ok(_) => {
-                                log::info!("Polling for new episodes successful");
+                                info!("Polling for new episodes successful");
                             }
                             Err(e) => {
                                 log::error!("Error polling for new episodes: {}", e);

src/controllers/podcast_controller.rs

@@ -418,7 +418,10 @@ pub async fn refresh_all_podcasts(
     let podcasts = Podcast::get_all_podcasts()?;
     thread::spawn(move || {
         for podcast in podcasts {
-            PodcastService::refresh_podcast(podcast.clone()).unwrap();
+            let refresh_result = PodcastService::refresh_podcast(&podcast);
+            if let Err(e) = refresh_result {
+                log::error!("Error refreshing podcast: {}", e);
+            }
             ChatServerHandle::broadcast_podcast_refreshed(&podcast);
         }
     });
@@ -443,7 +446,7 @@ pub async fn download_podcast(
     let id_num = from_str::<i32>(&id).unwrap();
     let podcast = PodcastService::get_podcast_by_id(id_num);
     thread::spawn(move || {
-        match PodcastService::refresh_podcast(podcast.clone()) {
+        match PodcastService::refresh_podcast(&podcast) {
             Ok(_) => {
                 log::info!("Succesfully refreshed podcast.");
             }
@@ -452,7 +455,7 @@ pub async fn download_podcast(
             }
         }
 
-        let download = PodcastService::schedule_episode_download(podcast.clone());
+        let download = PodcastService::schedule_episode_download(&podcast);
 
         if download.is_err() {
             log::error!("Error downloading podcast: {}", download.err().unwrap());

src/controllers/server.rs

@@ -205,10 +205,10 @@ impl ChatServerHandle {
         );
     }
 
-    pub fn broadcast_added_podcast_episodes(podcast: Podcast, episodes: Vec<PodcastEpisode>) {
+    pub fn broadcast_added_podcast_episodes(podcast: &Podcast, episodes: Vec<PodcastEpisode>) {
         Self::send_broadcast_sync(
             MAIN_ROOM.parse().unwrap(),
-            &PodcastEpisodesAdded::from((podcast, episodes)),
+            &PodcastEpisodesAdded::from((podcast.clone(), episodes)),
             "addedEpisodes",
         );
     }

src/service/podcast_episode_service.rs

@@ -16,7 +16,7 @@ use crate::service::file_service::FileService;
 use crate::service::settings_service::SettingsService;
 use crate::service::telegram_api::send_new_episode_notification;
 use crate::utils::environment_variables::is_env_var_present_and_true;
-use crate::utils::error::{map_db_error, CustomError, CustomErrorInner};
+use crate::utils::error::{map_db_error, map_reqwest_error, CustomError, CustomErrorInner};
 use crate::utils::podcast_builder::PodcastBuilder;
 use crate::utils::reqwest_client::get_sync_client;
 use diesel::{ExpressionMethods, OptionalExtension, QueryDsl, RunQueryDsl};
@@ -100,10 +100,11 @@ impl PodcastEpisodeService {
     }
 
     // Used for creating/updating podcasts
-    pub fn insert_podcast_episodes(podcast: Podcast) -> Result<Vec<PodcastEpisode>, CustomError> {
+    pub fn insert_podcast_episodes(podcast: &Podcast) -> Result<Vec<PodcastEpisode>, CustomError> {
         let is_redirected = Arc::new(Mutex::new(false)); // Variable to store the redirection status
 
-        let returned_data_from_podcast_insert = Self::do_request_to_podcast_server(podcast.clone());
+        let returned_data_from_podcast_insert = Self::do_request_to_podcast_server(podcast.clone
+        ())?;
 
         let channel = Channel::read_from(returned_data_from_podcast_insert.content.as_bytes());
 
@@ -122,13 +123,13 @@ impl PodcastEpisodeService {
                     Self::update_episodes_on_redirect(channel.items())?;
                 }
 
-                Self::handle_itunes_extension(&podcast, &channel)?;
+                Self::handle_itunes_extension(podcast, &channel)?;
 
                 Self::update_podcast_fields(channel.clone(), podcast.id)?;
 
                 let mut podcast_inserted = Vec::new();
 
-                Self::handle_podcast_image_insert(&podcast, &channel)?;
+                Self::handle_podcast_image_insert(podcast, &channel)?;
 
                 for item in channel.items.iter() {
                     let itunes_ext = item.clone().itunes_ext;
@@ -289,7 +290,8 @@ impl PodcastEpisodeService {
                 let new_url = extension.new_feed_url.unwrap();
                 Podcast::update_podcast_urls_on_redirect(podcast.id, new_url);
 
-                let returned_data_from_server = Self::do_request_to_podcast_server(podcast.clone());
+                let returned_data_from_server = Self::do_request_to_podcast_server(podcast.clone
+                ())?;
 
                 let channel =
                     Channel::read_from(returned_data_from_server.content.as_bytes()).unwrap();
@@ -483,7 +485,7 @@ impl PodcastEpisodeService {
         PodcastEpisode::get_podcast_episode_by_id(id_num)
     }
 
-    fn do_request_to_podcast_server(podcast: Podcast) -> RequestReturnType {
+    fn do_request_to_podcast_server(podcast: Podcast) -> Result<RequestReturnType, CustomError> {
         let is_redirected = Arc::new(Mutex::new(false)); // Variable to store the redirection status
         let client = get_sync_client()
             .redirect(Policy::custom({
@@ -497,22 +499,23 @@ impl PodcastEpisodeService {
                 }
             }))
             .build()
-            .unwrap();
+            .map_err(map_reqwest_error)?;
         let mut header_map = HeaderMap::new();
         header_map.append(
             ACCEPT,
+            // Safe as it is a standard header
             "application/rss+xml,application/xml".parse().unwrap(),
         );
         header_map.append("User-Agent", COMMON_USER_AGENT.parse().unwrap());
         let result = client
             .get(podcast.clone().rssfeed)
             .headers(header_map)
             .send()
-            .unwrap();
+            .map_err(map_reqwest_error)?;
         let url = result.url().clone().to_string();
-        let content = result.text().unwrap().clone();
+        let content = result.text().map_err(map_reqwest_error)?;
 
-        RequestReturnType { url, content }
+        Ok(RequestReturnType { url, content })
     }
 
     pub(crate) fn delete_podcast_episode_locally(

src/service/rust_service.rs

@@ -148,13 +148,13 @@ impl PodcastService {
                 spawn_blocking(move || {
                     log::debug!("Inserting podcast episodes of {}", podcast.name);
                     let inserted_podcasts =
-                        PodcastEpisodeService::insert_podcast_episodes(podcast.clone()).unwrap();
+                        PodcastEpisodeService::insert_podcast_episodes(&podcast).unwrap();
 
                     ChatServerHandle::broadcast_added_podcast_episodes(
-                        podcast.clone(),
+                        &podcast,
                         inserted_podcasts.clone(),
                     );
-                    if let Err(e) = Self::schedule_episode_download(podcast) {
+                    if let Err(e) = Self::schedule_episode_download(&podcast) {
                         log::error!("Error scheduling episode download: {}", e);
                     }
                 })
@@ -168,7 +168,7 @@ impl PodcastService {
         }
     }
 
-    pub fn schedule_episode_download(podcast: Podcast) -> Result<(), CustomError> {
+    pub fn schedule_episode_download(podcast: &Podcast) -> Result<(), CustomError> {
         let settings = Setting::get_settings()?;
         let podcast_settings = PodcastSetting::get_settings(podcast.id)?;
         match settings {
@@ -199,10 +199,10 @@ impl PodcastService {
         }
     }
 
-    pub fn refresh_podcast(podcast: Podcast) -> Result<(), CustomError> {
+    pub fn refresh_podcast(podcast: &Podcast) -> Result<(), CustomError> {
         log::info!("Refreshing podcast: {}", podcast.name);
-        PodcastEpisodeService::insert_podcast_episodes(podcast.clone())?;
-        Self::schedule_episode_download(podcast.clone())
+        PodcastEpisodeService::insert_podcast_episodes(podcast)?;
+        Self::schedule_episode_download(podcast)
     }
 
     pub fn update_favor_podcast(id: i32, x: bool, username: &str) -> Result<(), CustomError> {