Line data    Source code

       1              : use pageserver_api::shard::TenantShardId;
       2              : use s3_scrubber::garbage::{find_garbage, purge_garbage, PurgeMode};
       3              : use s3_scrubber::scan_metadata::scan_metadata;
       4              : use s3_scrubber::{init_logging, BucketConfig, ConsoleConfig, NodeKind, TraversingDepth};
       5              : 
       6              : use clap::{Parser, Subcommand};
       7              : 
       8            0 : #[derive(Parser)]
       9              : #[command(author, version, about, long_about = None)]
      10              : #[command(arg_required_else_help(true))]
      11              : struct Cli {
      12              :     #[command(subcommand)]
      13              :     command: Command,
      14              : 
      15            0 :     #[arg(short, long, default_value_t = false)]
      16            0 :     delete: bool,
      17              : }
      18              : 
      19            0 : #[derive(Subcommand, Debug)]
      20              : enum Command {
      21              :     FindGarbage {
      22              :         #[arg(short, long)]
      23            0 :         node_kind: NodeKind,
      24            0 :         #[arg(short, long, default_value_t=TraversingDepth::Tenant)]
      25            0 :         depth: TraversingDepth,
      26            0 :         #[arg(short, long, default_value_t = String::from("garbage.json"))]
      27            0 :         output_path: String,
      28              :     },
      29              :     PurgeGarbage {
      30              :         #[arg(short, long)]
      31            0 :         input_path: String,
      32            0 :         #[arg(short, long, default_value_t = PurgeMode::DeletedOnly)]
      33            0 :         mode: PurgeMode,
      34              :     },
      35              :     ScanMetadata {
      36            0 :         #[arg(short, long, default_value_t = false)]
      37            0 :         json: bool,
      38              :         #[arg(long = "tenant-id", num_args = 0..)]
      39            0 :         tenant_ids: Vec<TenantShardId>,
      40              :     },
      41              : }
      42              : 
      43              : #[tokio::main]
      44            0 : async fn main() -> anyhow::Result<()> {
      45            0 :     let cli = Cli::parse();
      46              : 
      47            0 :     let bucket_config = BucketConfig::from_env()?;
      48              : 
      49            0 :     let command_log_name = match &cli.command {
      50            0 :         Command::ScanMetadata { .. } => "scan",
      51            0 :         Command::FindGarbage { .. } => "find-garbage",
      52            0 :         Command::PurgeGarbage { .. } => "purge-garbage",
      53              :     };
      54            0 :     let _guard = init_logging(&format!(
      55            0 :         "{}_{}_{}_{}.log",
      56            0 :         std::env::args().next().unwrap(),
      57            0 :         command_log_name,
      58            0 :         bucket_config.bucket,
      59            0 :         chrono::Utc::now().format("%Y_%m_%d__%H_%M_%S")
      60            0 :     ));
      61            0 : 
      62            0 :     match cli.command {
      63            0 :         Command::ScanMetadata { json, tenant_ids } => {
      64            0 :             match scan_metadata(bucket_config.clone(), tenant_ids).await {
      65            0 :                 Err(e) => {
      66            0 :                     tracing::error!("Failed: {e}");
      67            0 :                     Err(e)
      68              :                 }
      69            0 :                 Ok(summary) => {
      70            0 :                     if json {
      71            0 :                         println!("{}", serde_json::to_string(&summary).unwrap())
      72            0 :                     } else {
      73            0 :                         println!("{}", summary.summary_string());
      74            0 :                     }
      75            0 :                     if summary.is_fatal() {
      76            0 :                         Err(anyhow::anyhow!("Fatal scrub errors detected"))
      77            0 :                     } else if summary.is_empty() {
      78              :                         // Strictly speaking an empty bucket is a valid bucket, but if someone ran the
      79              :                         // scrubber they were likely expecting to scan something, and if we see no timelines
      80              :                         // at all then it's likely due to some configuration issues like a bad prefix
      81            0 :                         Err(anyhow::anyhow!(
      82            0 :                             "No timelines found in bucket {} prefix {}",
      83            0 :                             bucket_config.bucket,
      84            0 :                             bucket_config
      85            0 :                                 .prefix_in_bucket
      86            0 :                                 .unwrap_or("<none>".to_string())
      87            0 :                         ))
      88              :                     } else {
      89            0 :                         Ok(())
      90              :                     }
      91              :                 }
      92              :             }
      93              :         }
      94              :         Command::FindGarbage {
      95            0 :             node_kind,
      96            0 :             depth,
      97            0 :             output_path,
      98              :         } => {
      99            0 :             let console_config = ConsoleConfig::from_env()?;
     100            0 :             find_garbage(bucket_config, console_config, depth, node_kind, output_path).await
     101              :         }
     102            0 :         Command::PurgeGarbage { input_path, mode } => {
     103            0 :             purge_garbage(input_path, mode, !cli.delete).await
     104              :         }
     105              :     }
     106              : }