feat(Prover CLI): status batch command

prover/prover_cli/Cargo.toml

@@ -29,4 +29,3 @@ zksync_types.workspace = true
 zksync_prover_fri_types.workspace = true
 zksync_prover_interface.workspace = true
 prover_dal.workspace = true
-

prover/prover_cli/src/cli.rs

@@ -1,6 +1,6 @@
 use clap::{command, Parser, Subcommand};
 
-use crate::commands::get_file_info;
+use crate::commands::{get_file_info, jobs_status};
 
 pub const VERSION_STRING: &str = env!("CARGO_PKG_VERSION");
 
@@ -14,12 +14,14 @@ struct ProverCLI {
 #[derive(Subcommand)]
 enum ProverCommand {
     FileInfo(get_file_info::Args),
+    StatusJobs(jobs_status::Args),
 }
 
 pub async fn start() -> anyhow::Result<()> {
     let ProverCLI { command } = ProverCLI::parse();
     match command {
         ProverCommand::FileInfo(args) => get_file_info::run(args).await?,
+        ProverCommand::StatusJobs(args) => jobs_status::run(args).await?,
     };
 
     Ok(())

prover/prover_cli/src/commands/jobs_status.rs

@@ -0,0 +1,63 @@
+use anyhow::Context as _;
+use clap::Args as ClapArgs;
+use prover_dal::{ConnectionPool, Prover, ProverDal};
+use zksync_basic_types::{prover_dal::JobCountStatistics, L1BatchNumber};
+use zksync_config::PostgresConfig;
+use zksync_env_config::FromEnv;
+
+#[derive(ClapArgs)]
+pub(crate) struct Args {
+    #[clap(short, long, num_args = 0..)]
+    batch: Vec<L1BatchNumber>,
+    #[clap(short, long, default_value("false"))]
+    verbose: bool,
+}
+
+fn pretty_print_job_status(
+    l1_batch_number: &L1BatchNumber,
+    statistics: &JobCountStatistics,
+    verbose: bool,
+) {
+    let total_jobs =
+        statistics.queued + statistics.in_progress + statistics.failed + statistics.successful;
+    let progress = (statistics.successful as f32 / total_jobs as f32) * 100.0;
+    println!("Batch number: {}", l1_batch_number);
+    println!(
+        "Progress: {:.2}% ({}/{})",
+        progress, statistics.successful, total_jobs
+    );
+    if verbose {
+        println!("In progress: {}", statistics.in_progress);
+        println!("Queued: {}", statistics.in_progress);
+        println!("Successful: {}", statistics.in_progress);
+    }
+    println!("Failed: {}", statistics.failed);
+}
+
+pub(crate) async fn run(args: Args) -> anyhow::Result<()> {
+    let postgres_config = PostgresConfig::from_env().context("PostgresConfig::from_env()")?;
+
+    let prover_connection_pool = ConnectionPool::<Prover>::builder(
+        postgres_config.prover_url()?,
+        postgres_config.max_connections()?,
+    )
+    .build()
+    .await
+    .context("failed to build a prover_connection_pool")?;
+
+    let mut conn = prover_connection_pool.connection().await.unwrap();
+    let stats = conn
+        .fri_prover_jobs_dal()
+        .get_prover_jobs_stats_for_batch(args.batch)
+        .await;
+    if stats.len() > 0 {
+        for row in &stats {
+            let (l1_batch_number, statistics) = row;
+
+            pretty_print_job_status(l1_batch_number, statistics, args.verbose)
+        }
+    } else {
+        println!("No batches found.")
+    }
+    Ok(())
+}

prover/prover_cli/src/commands/mod.rs

@@ -1 +1,2 @@
 pub(crate) mod get_file_info;
+pub(crate) mod jobs_status;

prover/prover_dal/src/fri_prover_dal.rs

@@ -594,4 +594,57 @@ impl FriProverDal<'_, '_> {
         .unwrap()
         .unwrap_or(0) as usize
     }
+
+    pub async fn get_prover_jobs_stats_for_batch(
+        &mut self,
+        l1_batches_numbers: Vec<L1BatchNumber>,
+    ) -> HashMap<L1BatchNumber, JobCountStatistics> {
+        {
+            sqlx::query!(
+                r#"
+                SELECT
+                    COUNT(*) AS "count!",
+                    l1_batch_number AS "l1_batch_number!",
+                    status AS "status!"
+                FROM
+                    prover_jobs_fri
+                WHERE
+                    l1_batch_number = ANY ($1)
+                GROUP BY
+                    l1_batch_number,
+                    status
+                "#,
+                &l1_batches_numbers
+                    .into_iter()
+                    .map(|x| i64::from(x.0))
+                    .collect::<Vec<i64>>()
+            )
+            .fetch_all(self.storage.conn())
+            .await
+            .unwrap()
+            .into_iter()
+            .map(|row| (row.l1_batch_number, row.status, row.count as usize))
+            .fold(
+                HashMap::new(),
+                |mut acc, (l1_batch_number, status, value)| {
+                    let stats = acc.entry(L1BatchNumber(l1_batch_number as u32)).or_insert(
+                        JobCountStatistics {
+                            queued: 0,
+                            in_progress: 0,
+                            failed: 0,
+                            successful: 0,
+                        },
+                    );
+                    match status.as_ref() {
+                        "queued" => stats.queued = value,
+                        "in_progress" => stats.in_progress = value,
+                        "failed" => stats.failed = value,
+                        "successful" => stats.successful = value,
+                        _ => (),
+                    }
+                    acc
+                },
+            )
+        }
+    }
 }