Implement a max_retries option.

This lets rebuilders set an upper limit for the number of times BAD packages will be retried.

Author: Nihlus

common/src/config.rs

@@ -135,16 +135,25 @@ impl WorkerConfig {
 #[derive(Debug, Default, Clone, Deserialize)]
 pub struct ScheduleConfig {
     retry_delay_base: Option<i64>,
+    max_retries: Option<u64>,
 }
 
 impl ScheduleConfig {
     pub fn update(&mut self, c: ScheduleConfig) {
         if c.retry_delay_base.is_some() {
             self.retry_delay_base = c.retry_delay_base;
         }
+
+        if c.max_retries.is_some() {
+            self.max_retries = c.max_retries;
+        }
     }
 
     pub fn retry_delay_base(&self) -> i64 {
         self.retry_delay_base.unwrap_or(DEFAULT_RETRY_DELAY_BASE)
     }
+
+    pub fn max_retries(&self) -> Option<u64> {
+        self.max_retries
+    }
 }

contrib/confs/rebuilderd.conf

@@ -37,8 +37,11 @@
 ## Configure the delay to automatically retry failed rebuilds in hours. The
 ## default is 24h, this base is multiplied with the number of rebuilds, so the
 ## first retry would happen after 24h, the second retry would happen 48h after the
-## first retry and the third retry would happen 72h after the second retry. There
-## is no upper limit of retries, if you can't afford frequent retries it's
-## recommended to set this to a high value like 168 (1 week) or higher.
+## first retry and the third retry would happen 72h after the second retry. By default, there is no upper limit to the
+## number of retries; however, you may set one with max_retries.
 ## Successful rebuilds are not retried.
 #retry_delay_base = 24
+
+## Configure the maximum number of times an unreproducible package will be retried (0 to N). There is no default upper
+## limit.
+#max_retries =

daemon/src/api/v1/build.rs

@@ -15,7 +15,7 @@ use crate::schema::{
 };
 use crate::{attestation, web};
 use actix_web::{get, post, HttpRequest, HttpResponse, Responder};
-use chrono::{Duration, Utc};
+use chrono::{Duration, NaiveDateTime, Utc};
 use diesel::dsl::update;
 use diesel::NullableExpressionMethods;
 use diesel::QueryDsl;
@@ -221,6 +221,20 @@ pub async fn submit_rebuild_report(
             .get_result::<i32>(connection.as_mut())
             .map_err(Error::from)?;
 
+        // bail if we have a max retry count set and requeueing this package would exceed it
+        if let Some(max_retries) = cfg.schedule.max_retries() {
+            if retry_count + 1 > max_retries as i32 {
+                // null out the next retry to mark the package as non-retried
+                update(build_inputs::table)
+                    .filter(build_inputs::id.eq_any(&friends))
+                    .set(build_inputs::next_retry.eq(None::<NaiveDateTime>))
+                    .execute(connection.as_mut())
+                    .map_err(Error::from)?;
+
+                return Ok(HttpResponse::NoContent());
+            }
+        }
+
         let now = Utc::now();
         let then = now + Duration::hours(((retry_count + 1) * 24) as i64);
 

daemon/src/api/v1/package.rs

@@ -10,7 +10,7 @@ use crate::schema::{
 };
 use crate::web;
 use actix_web::{get, post, HttpRequest, HttpResponse, Responder};
-use chrono::Utc;
+use chrono::{NaiveDateTime, Utc};
 use diesel::dsl::{delete, exists, not, select, update};
 use diesel::r2d2::{ConnectionManager, PooledConnection};
 use diesel::sql_types::Integer;
@@ -242,6 +242,29 @@ pub async fn submit_package_report(
             let has_queued_friend = has_queued_friend(conn, &build_input)?;
 
             if current_status != BuildStatus::Good && !has_queued_friend {
+                let retry_count = build_inputs::table
+                    .filter(build_inputs::id.is(build_input.id))
+                    .select(build_inputs::retries)
+                    .get_result::<i32>(conn)?;
+
+                // bail if we have a max retry count set and requeueing this package would exceed it
+                if let Some(max_retries) = cfg.schedule.max_retries() {
+                    if retry_count + 1 > max_retries as i32 {
+                        // null out the next retry to mark the package as non-retried
+                        update(build_inputs::table)
+                            .filter(build_inputs::id.eq(build_input.id))
+                            .set(build_inputs::next_retry.eq(None::<NaiveDateTime>))
+                            .execute(conn)?;
+
+                        // drop any enqueued jobs for the build input
+                        delete(queue::table)
+                            .filter(queue::build_input_id.eq(build_input.id))
+                            .execute(conn)?;
+
+                        return Ok::<(), Error>(());
+                    }
+                }
+
                 let priority = match current_status {
                     BuildStatus::Bad => Priority::retry(),
                     _ => Priority::default(),