refactor worker into worker/worker_job

src/main.rs

@@ -73,20 +73,17 @@ impl Resources {
         queue.pop_front()
     }
 
-    fn worker(&self) -> Result<(), Error> {
-        let db = PgConnection::establish(&self.db_url)?;
-
-        loop {
+    fn worker_job(&self, db: &PgConnection) -> Result<bool, Error> {
         let (id, cal_opts) = match self.next() {
             Some(next) => next,
-                None => return Ok(()),
+            None => return Ok(true),
         };
 
         let (etag, last_modified) = db.transaction::<_, Error, _>(|| {
             let cals = calendars
                 .filter(schema::calendars::dsl::id.eq(id.clone()))
                 .limit(1)
-                    .load::<Calendar>(&db)?;
+                .load::<Calendar>(db)?;
             match cals.first() {
                 None => {
                     let cal = NewCalendar {
@@ -96,14 +93,14 @@ impl Resources {
                     };
                     diesel::insert_into(calendars)
                         .values(&cal)
-                            .execute(&db)?;
+                        .execute(db)?;
                     Ok((None, None))
                 }
                 Some(cal) => {
                     diesel::update(calendars)
                         .filter(schema::calendars::dsl::id.eq(id.clone()))
                         .set(schema::calendars::dsl::last_fetch.eq(Utc::now().naive_utc()))
-                            .execute(&db)?;
+                        .execute(db)?;
                     let result =
                     // Use ETag/Last-Modified only if URL hasn't changed
                         if cal.url == cal_opts.url {
@@ -135,8 +132,8 @@ impl Resources {
                 .filter(schema::calendars::dsl::id.eq(id.clone()))
                 .set((schema::calendars::dsl::last_success.eq(Utc::now().naive_utc()),
                       schema::calendars::dsl::error_message.eq(msg)))
-                    .execute(&db)?;
-                return Ok(())
+                .execute(db)?;
+            return Ok(false)
         }
 
         let etag = res.headers().get(ETAG)
@@ -152,7 +149,7 @@ impl Resources {
                 .set((schema::calendars::dsl::last_success.eq(Utc::now().naive_utc()),
                       schema::calendars::dsl::etag.eq(etag),
                       schema::calendars::dsl::last_modified.eq(last_modified)))
-                    .execute(&db)?;
+                .execute(db)?;
 
             let mut p = Parser::new();
             let mut buf = [0; 1024];
@@ -184,16 +181,28 @@ impl Resources {
             println!("[{}] {} events", id, events.len());
             diesel::delete(schema::events::dsl::events)
                 .filter(schema::events::dsl::calendar.eq(id))
-                    .execute(&db)?;
+                .execute(db)?;
             for event in events.values() {
                 diesel::insert_into(schema::events::dsl::events)
                     .values(event)
-                        .execute(&db)?;
+                    .execute(db)?;
             }
 
-                Ok(())
+            Ok(false)
         })?;
+
+        Ok(false)
     }
+
+    fn worker_loop(&self) -> Result<(), Error> {
+        let db = PgConnection::establish(&self.db_url)?;
+        let mut done = false;
+        while ! done {
+            done = self.worker_job(&db)
+                .map_err(|e| println!("{:?}", e))
+                .unwrap_or(false);
+        }
+        Ok(())
     }
 }
 
@@ -244,7 +253,7 @@ fn main() {
         let cpus = num_cpus::get();
         let workers: Vec<_> = (0..cpus)
             .map(|_| s.spawn(|_| {
-                res.worker()
+                res.worker_loop()
                     .map_err(|e| println!("{:?}", e))
             }))
             .collect();