Replaced pool.get().unwrap() statements with get()?.

hammond-data/src/database.rs

@@ -49,13 +49,12 @@ fn init_pool(db_path: &str) -> Pool {
         .build();
     let manager = ConnectionManager::<SqliteConnection>::new(db_path);
     let pool = Arc::new(r2d2::Pool::new(config, manager).expect("Failed to create pool."));
-    info!("Database pool initialized.");
 
     {
-        let db = Arc::clone(&pool).get().unwrap();
+        let db = Arc::clone(&pool).get().expect("Failed to initialize pool.");
-        run_migration_on(&*db).unwrap();
+        run_migration_on(&*db).expect("Failed to run migrations during init.");
     }
-
+    info!("Database pool initialized.");
     pool
 }
 

hammond-data/src/dbqueries.rs

@@ -2,155 +2,156 @@ use diesel::prelude::*;
 use diesel;
 use models::{Episode, NewEpisode, NewPodcast, NewSource, Podcast, Source};
 use chrono::prelude::*;
+use errors::*;
 
 /// Random db querries helper functions.
 /// Probably needs cleanup.
 
 use database::connection;
 
-pub fn get_sources() -> QueryResult<Vec<Source>> {
+pub fn get_sources() -> Result<Vec<Source>> {
     use schema::source::dsl::*;
 
     let db = connection();
-    let con = db.get().unwrap();
+    let con = db.get()?;
-    source.load::<Source>(&*con)
+    Ok(source.load::<Source>(&*con)?)
 }
 
-pub fn get_podcasts() -> QueryResult<Vec<Podcast>> {
+pub fn get_podcasts() -> Result<Vec<Podcast>> {
     use schema::podcast::dsl::*;
 
     let db = connection();
-    let con = db.get().unwrap();
+    let con = db.get()?;
-    podcast.load::<Podcast>(&*con)
+    Ok(podcast.load::<Podcast>(&*con)?)
 }
 
-pub fn get_episodes() -> QueryResult<Vec<Episode>> {
+pub fn get_episodes() -> Result<Vec<Episode>> {
     use schema::episode::dsl::*;
 
     let db = connection();
-    let con = db.get().unwrap();
+    let con = db.get()?;
-    episode.order(epoch.desc()).load::<Episode>(&*con)
+    Ok(episode.order(epoch.desc()).load::<Episode>(&*con)?)
 }
 
-pub fn get_downloaded_episodes() -> QueryResult<Vec<Episode>> {
+pub fn get_downloaded_episodes() -> Result<Vec<Episode>> {
     use schema::episode::dsl::*;
 
     let db = connection();
-    let con = db.get().unwrap();
+    let con = db.get()?;
-    episode
+    Ok(episode
         .filter(local_uri.is_not_null())
-        .load::<Episode>(&*con)
+        .load::<Episode>(&*con)?)
 }
 
-pub fn get_played_episodes() -> QueryResult<Vec<Episode>> {
+pub fn get_played_episodes() -> Result<Vec<Episode>> {
     use schema::episode::dsl::*;
 
     let db = connection();
-    let con = db.get().unwrap();
+    let con = db.get()?;
-    episode.filter(played.is_not_null()).load::<Episode>(&*con)
+    Ok(episode.filter(played.is_not_null()).load::<Episode>(&*con)?)
 }
 
-pub fn get_episode_from_id(ep_id: i32) -> QueryResult<Episode> {
+pub fn get_episode_from_id(ep_id: i32) -> Result<Episode> {
     use schema::episode::dsl::*;
 
     let db = connection();
-    let con = db.get().unwrap();
+    let con = db.get()?;
-    episode.filter(id.eq(ep_id)).get_result::<Episode>(&*con)
+    Ok(episode.filter(id.eq(ep_id)).get_result::<Episode>(&*con)?)
 }
 
-pub fn get_episode_local_uri_from_id(ep_id: i32) -> QueryResult<Option<String>> {
+pub fn get_episode_local_uri_from_id(ep_id: i32) -> Result<Option<String>> {
     use schema::episode::dsl::*;
 
     let db = connection();
-    let con = db.get().unwrap();
+    let con = db.get()?;
 
-    episode
+    Ok(episode
         .filter(id.eq(ep_id))
         .select(local_uri)
-        .get_result::<Option<String>>(&*con)
+        .get_result::<Option<String>>(&*con)?)
 }
 
-pub fn get_episodes_with_limit(limit: u32) -> QueryResult<Vec<Episode>> {
+pub fn get_episodes_with_limit(limit: u32) -> Result<Vec<Episode>> {
     use schema::episode::dsl::*;
 
     let db = connection();
-    let con = db.get().unwrap();
+    let con = db.get()?;
 
-    episode
+    Ok(episode
         .order(epoch.desc())
         .limit(i64::from(limit))
-        .load::<Episode>(&*con)
+        .load::<Episode>(&*con)?)
 }
 
-pub fn get_podcast_from_id(pid: i32) -> QueryResult<Podcast> {
+pub fn get_podcast_from_id(pid: i32) -> Result<Podcast> {
     use schema::podcast::dsl::*;
 
     let db = connection();
-    let con = db.get().unwrap();
+    let con = db.get()?;
-    podcast.filter(id.eq(pid)).get_result::<Podcast>(&*con)
+    Ok(podcast.filter(id.eq(pid)).get_result::<Podcast>(&*con)?)
 }
 
-pub fn get_pd_episodes(parent: &Podcast) -> QueryResult<Vec<Episode>> {
+pub fn get_pd_episodes(parent: &Podcast) -> Result<Vec<Episode>> {
     use schema::episode::dsl::*;
 
     let db = connection();
-    let con = db.get().unwrap();
+    let con = db.get()?;
 
-    Episode::belonging_to(parent)
+    Ok(Episode::belonging_to(parent)
         .order(epoch.desc())
-        .load::<Episode>(&*con)
+        .load::<Episode>(&*con)?)
 }
 
-pub fn get_pd_unplayed_episodes(parent: &Podcast) -> QueryResult<Vec<Episode>> {
+pub fn get_pd_unplayed_episodes(parent: &Podcast) -> Result<Vec<Episode>> {
     use schema::episode::dsl::*;
 
     let db = connection();
-    let con = db.get().unwrap();
+    let con = db.get()?;
 
-    Episode::belonging_to(parent)
+    Ok(Episode::belonging_to(parent)
         .filter(played.is_null())
         .order(epoch.desc())
-        .load::<Episode>(&*con)
+        .load::<Episode>(&*con)?)
 }
 
-pub fn get_pd_episodes_limit(parent: &Podcast, limit: u32) -> QueryResult<Vec<Episode>> {
+pub fn get_pd_episodes_limit(parent: &Podcast, limit: u32) -> Result<Vec<Episode>> {
     use schema::episode::dsl::*;
 
     let db = connection();
-    let con = db.get().unwrap();
+    let con = db.get()?;
 
-    Episode::belonging_to(parent)
+    Ok(Episode::belonging_to(parent)
         .order(epoch.desc())
         .limit(i64::from(limit))
-        .load::<Episode>(&*con)
+        .load::<Episode>(&*con)?)
 }
 
-pub fn get_source_from_uri(uri_: &str) -> QueryResult<Source> {
+pub fn get_source_from_uri(uri_: &str) -> Result<Source> {
     use schema::source::dsl::*;
 
     let db = connection();
-    let con = db.get().unwrap();
+    let con = db.get()?;
-    source.filter(uri.eq(uri_)).get_result::<Source>(&*con)
+    Ok(source.filter(uri.eq(uri_)).get_result::<Source>(&*con)?)
 }
 
 // pub fn get_podcast_from_title(title_: &str) -> QueryResult<Podcast> {
 //     use schema::podcast::dsl::*;
 
 //     let db = connection();
-//     let con = db.get().unwrap();
+//     let con = db.get()?;
 //     podcast
 //         .filter(title.eq(title_))
 //         .get_result::<Podcast>(&*con)
 // }
 
-pub fn get_podcast_from_source_id(sid: i32) -> QueryResult<Podcast> {
+pub fn get_podcast_from_source_id(sid: i32) -> Result<Podcast> {
     use schema::podcast::dsl::*;
 
     let db = connection();
-    let con = db.get().unwrap();
+    let con = db.get()?;
-    podcast
+    Ok(podcast
         .filter(source_id.eq(sid))
-        .get_result::<Podcast>(&*con)
+        .get_result::<Podcast>(&*con)?)
 }
 
 pub fn get_episode_from_uri(con: &SqliteConnection, uri_: &str) -> QueryResult<Episode> {
@@ -159,11 +160,11 @@ pub fn get_episode_from_uri(con: &SqliteConnection, uri_: &str) -> QueryResult<E
     episode.filter(uri.eq(uri_)).get_result::<Episode>(&*con)
 }
 
-pub fn remove_feed(pd: &Podcast) -> QueryResult<()> {
+pub fn remove_feed(pd: &Podcast) -> Result<()> {
     let db = connection();
-    let con = db.get().unwrap();
+    let con = db.get()?;
 
-    con.transaction(|| -> QueryResult<()> {
+    con.transaction(|| -> Result<()> {
         delete_source(&con, pd.source_id())?;
         delete_podcast(&con, *pd.id())?;
         delete_podcast_episodes(&con, *pd.id())?;
@@ -190,17 +191,18 @@ pub fn delete_podcast_episodes(con: &SqliteConnection, parent_id: i32) -> QueryR
     diesel::delete(episode.filter(podcast_id.eq(parent_id))).execute(&*con)
 }
 
-pub fn update_none_to_played_now(parent: &Podcast) -> QueryResult<usize> {
+pub fn update_none_to_played_now(parent: &Podcast) -> Result<usize> {
     use schema::episode::dsl::*;
 
     let db = connection();
-    let con = db.get().unwrap();
+    let con = db.get()?;
 
     let epoch_now = Utc::now().timestamp() as i32;
-    con.transaction(|| -> QueryResult<usize> {
+    con.transaction(|| -> Result<usize> {
-        diesel::update(Episode::belonging_to(parent).filter(played.is_null()))
+        Ok(diesel::update(
-            .set(played.eq(Some(epoch_now)))
+            Episode::belonging_to(parent).filter(played.is_null()),
-            .execute(&*con)
+        ).set(played.eq(Some(epoch_now)))
+            .execute(&*con)?)
     })
 }
 

hammond-data/src/feed.rs

@@ -44,7 +44,7 @@ impl Feed {
     fn index_channel_items(&self, pd: &Podcast) -> Result<()> {
         let episodes = self.parse_channel_items(pd);
         let db = connection();
-        let con = db.get().unwrap();
+        let con = db.get()?;
 
         let _ = con.transaction::<(), Error, _>(|| {
             episodes.into_iter().for_each(|x| {
@@ -83,7 +83,7 @@ impl Feed {
         let eps = self.parse_channel_items(&pd);
 
         let db = connection();
-        let con = db.get().unwrap();
+        let con = db.get()?;
         // TODO: Make it parallel
         // This returns only the episodes in the xml feed.
         let episodes: Vec<_> = eps.into_iter()
@@ -142,7 +142,7 @@ mod tests {
 
     use rss;
     use models::Source;
-    use database::{connection, truncate_db};
+    use database::truncate_db;
 
     use std::fs;
     use std::io::BufReader;

hammond-data/src/models/insertables.rs

@@ -27,19 +27,19 @@ impl NewSource {
         }
     }
 
-    fn index(&self) {
+    fn index(&self) -> Result<()> {
         let db = connection();
-        let con = db.get().unwrap();
+        let con = db.get()?;
 
         // Throw away the result like `insert or ignore`
         // Diesel deos not support `insert or ignore` yet.
         let _ = dbqueries::insert_new_source(&con, self);
+        Ok(())
     }
 
     // Look out for when tryinto lands into stable.
-    pub fn into_source(self) -> QueryResult<Source> {
+    pub fn into_source(self) -> Result<Source> {
-        self.index();
+        self.index()?;
-
         dbqueries::get_source_from_uri(&self.uri)
     }
 }
@@ -108,11 +108,11 @@ impl NewPodcast {
         Ok(dbqueries::get_podcast_from_source_id(self.source_id)?)
     }
 
-    pub fn index(&self) -> QueryResult<()> {
+    pub fn index(&self) -> Result<()> {
         let pd = dbqueries::get_podcast_from_source_id(self.source_id);
 
         let db = connection();
-        let con = db.get().unwrap();
+        let con = db.get()?;
         match pd {
             Ok(foo) => {
                 if foo.source_id() != self.source_id {

hammond-data/src/models/queryables.rs

@@ -2,7 +2,6 @@ use chrono::prelude::*;
 
 use reqwest;
 use diesel::SaveChangesDsl;
-use diesel::result::QueryResult;
 use reqwest::header::{ETag, LastModified};
 use rss::Channel;
 
@@ -133,18 +132,18 @@ impl Episode {
         self.podcast_id
     }
 
-    pub fn set_played_now(&mut self) -> QueryResult<()> {
+    pub fn set_played_now(&mut self) -> Result<()> {
         let epoch = Utc::now().timestamp() as i32;
         self.set_played(Some(epoch));
         self.save()?;
         Ok(())
     }
 
-    pub fn save(&self) -> QueryResult<Episode> {
+    pub fn save(&self) -> Result<Episode> {
         let db = connection();
-        let tempdb = db.get().unwrap();
+        let tempdb = db.get()?;
 
-        self.save_changes::<Episode>(&*tempdb)
+        Ok(self.save_changes::<Episode>(&*tempdb)?)
     }
 }
 
@@ -222,11 +221,11 @@ impl Podcast {
         self.always_dl = b
     }
 
-    pub fn save(&self) -> QueryResult<Podcast> {
+    pub fn save(&self) -> Result<Podcast> {
         let db = connection();
-        let tempdb = db.get().unwrap();
+        let tempdb = db.get()?;
 
-        self.save_changes::<Podcast>(&*tempdb)
+        Ok(self.save_changes::<Podcast>(&*tempdb)?)
     }
 }
 
@@ -283,11 +282,11 @@ impl<'a> Source {
         Ok(())
     }
 
-    pub fn save(&self) -> QueryResult<Source> {
+    pub fn save(&self) -> Result<Source> {
         let db = connection();
-        let tempdb = db.get().unwrap();
+        let tempdb = db.get()?;
 
-        self.save_changes::<Source>(&*tempdb)
+        Ok(self.save_changes::<Source>(&*tempdb)?)
     }
 
     pub fn into_feed(mut self) -> Result<Feed> {
@@ -332,7 +331,7 @@ impl<'a> Source {
         Ok(Feed::from_channel_source(chan, self))
     }
 
-    pub fn from_url(uri: &str) -> QueryResult<Source> {
+    pub fn from_url(uri: &str) -> Result<Source> {
         NewSource::new_with_uri(uri).into_source()
     }
 }

hammond-downloader/src/errors.rs

@@ -1,5 +1,6 @@
 use diesel::result;
 use reqwest;
+use hammond_data;
 use std::io;
 
 error_chain! {
@@ -7,5 +8,6 @@ error_chain! {
         ReqError(reqwest::Error);
         IoError(io::Error);
         DieselResultError(result::Error);
+        DataError(hammond_data::errors::Error);
     }
 }