feat: handle processing proofs that have failed in the way

Author: MarcosNicolau

aggregation_mode/Cargo.lock

@@ -5,8 +5,7 @@ edition = "2021"
 
 [dependencies]
 tokio = { version = "1"}
-# TODO: enable tls
-sqlx = { version = "0.8", features = [ "runtime-tokio", "postgres", "migrate" ] }
+sqlx = { version = "0.8", features = [ "runtime-tokio", "postgres", "migrate", "chrono" ] }
 
 
 [[bin]]

aggregation_mode/db/Cargo.toml

@@ -9,7 +9,8 @@ CREATE TABLE tasks (
     merkle_path BYTEA,
     status task_status DEFAULT 'pending',
     nonce BIGINT NOT NULL,
-    inserted_at TIMESTAMPTZ NOT NULL DEFAULT now()
+    inserted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    status_updated_at TIMESTAMPTZ
 );
 
 CREATE TABLE payment_events (

aggregation_mode/db/migrations/001_init.sql

@@ -1,6 +1,9 @@
 use sqlx::{
     prelude::FromRow,
-    types::{BigDecimal, Uuid},
+    types::{
+        chrono::{DateTime, Utc},
+        BigDecimal, Uuid,
+    },
     Type,
 };
 
@@ -21,6 +24,7 @@ pub struct Task {
     pub program_commitment: Vec<u8>,
     pub merkle_path: Option<Vec<u8>>,
     pub status: TaskStatus,
+    pub status_updated_at: Option<DateTime<Utc>>,
 }
 
 #[derive(Debug, Clone, FromRow)]

aggregation_mode/db/src/types.rs

@@ -32,12 +32,19 @@ impl Db {
             "WITH selected AS (
                     SELECT task_id
                     FROM tasks
-                    WHERE proving_system_id = $1 AND status = 'pending'
+                    WHERE proving_system_id = $1
+                      AND (
+                        status = 'pending'
+                        OR (
+                            status = 'processing'
+                            AND status_updated_at <= now() - interval '12 hours'
+                        )
+                      )
                     LIMIT $2
                     FOR UPDATE SKIP LOCKED
                 )
                 UPDATE tasks t
-                SET status = 'processing'
+                SET status = 'processing', status_updated_at = now()
                 FROM selected s
                 WHERE t.task_id = s.task_id
                 RETURNING t.*;",
@@ -61,7 +68,7 @@ impl Db {
 
         for (task_id, merkle_path) in updates {
             if let Err(e) = sqlx::query(
-                "UPDATE tasks SET merkle_path = $1, status = 'verified', proof = NULL WHERE task_id = $2",
+                "UPDATE tasks SET merkle_path = $1, status = 'verified', status_updated_at = now(), proof = NULL WHERE task_id = $2",
             )
             .bind(merkle_path)
             .bind(task_id)
@@ -83,6 +90,20 @@ impl Db {
         Ok(())
     }
 
-    // TODO: this should be used when rolling back processing proofs on unexpected errors
-    pub async fn mark_tasks_as_pending(&self) {}
+    pub async fn mark_tasks_as_pending(&self, tasks_id: &[Uuid]) -> Result<(), DbError> {
+        if tasks_id.is_empty() {
+            return Ok(());
+        }
+
+        sqlx::query(
+            "UPDATE tasks SET status = 'pending', status_updated_at = now()
+             WHERE task_id = ANY($1) AND status = 'processing'",
+        )
+        .bind(tasks_id)
+        .execute(&self.pool)
+        .await
+        .map_err(|e| DbError::Query(e.to_string()))?;
+
+        Ok(())
+    }
 }

aggregation_mode/proof_aggregator/src/backend/db.rs

@@ -119,28 +119,40 @@ impl ProofAggregator {
         info!("Starting proof aggregator service");
 
         info!("About to aggregate and submit proof to be verified on chain");
-        let res = self.aggregate_and_submit_proofs_on_chain().await;
+
+        let (proofs, tasks_id) = match self
+            .fetcher
+            .fetch_pending_proofs(self.engine.clone(), self.config.total_proofs_limit as i64)
+            .await
+            .map_err(AggregatedProofSubmissionError::FetchingProofs)
+        {
+            Ok(res) => res,
+            Err(e) => {
+                error!("Error while aggregating and submitting proofs: {:?}", e);
+                return;
+            }
+        };
+
+        let res = self
+            .aggregate_and_submit_proofs_on_chain((proofs, &tasks_id))
+            .await;
 
         match res {
             Ok(()) => {
                 info!("Process finished successfully");
             }
             Err(err) => {
                 error!("Error while aggregating and submitting proofs: {:?}", err);
+                warn!("Marking tasks back to pending after failure");
+                self.db.mark_tasks_as_pending(&tasks_id).await;
             }
         }
     }
 
-    // TODO: on failure, mark proofs as pending again
     async fn aggregate_and_submit_proofs_on_chain(
         &mut self,
+        (proofs, tasks_id): (Vec<AlignedProof>, &[Uuid]),
     ) -> Result<(), AggregatedProofSubmissionError> {
-        let (proofs, tasks_id) = self
-            .fetcher
-            .fetch_pending_proofs(self.engine.clone(), self.config.total_proofs_limit as i64)
-            .await
-            .map_err(AggregatedProofSubmissionError::FetchingProofs)?;
-
         if proofs.is_empty() {
             warn!("No proofs collected, skipping aggregation...");
             return Ok(());
@@ -226,7 +238,7 @@ impl ProofAggregator {
                 .flat_map(|e| e.to_vec())
                 .collect::<Vec<_>>();
 
-            merkle_paths_for_tasks.push((task_id, proof_bytes))
+            merkle_paths_for_tasks.push((*task_id, proof_bytes))
         }
         self.db
             .insert_tasks_merkle_path_and_mark_them_as_verified(merkle_paths_for_tasks)