Cargo fmt

Author: CodingAnarchy

cargo-hammerwork/src/commands/backup.rs

@@ -178,8 +178,11 @@ async fn create_backup(
     match format {
         "csv" => {
             // CSV format
-            writeln!(writer, "id,queue_name,payload,status,priority,attempts,max_attempts,created_at,scheduled_at,started_at,completed_at,failed_at,error_message")?;
-            
+            writeln!(
+                writer,
+                "id,queue_name,payload,status,priority,attempts,max_attempts,created_at,scheduled_at,started_at,completed_at,failed_at,error_message"
+            )?;
+
             for job in &job_data {
                 writeln!(
                     writer,
@@ -308,7 +311,10 @@ async fn restore_backup(
         restored += 1;
     }
 
-    info!("✅ Restore completed: {} jobs restored, {} skipped", restored, skipped);
+    info!(
+        "✅ Restore completed: {} jobs restored, {} skipped",
+        restored, skipped
+    );
     println!("📥 Restore completed successfully");
     println!("   Restored: {} jobs", restored);
     if skipped > 0 {
@@ -345,13 +351,13 @@ async fn insert_job_from_backup(pool: &DatabasePool, job: &Value) -> Result<()>
     let priority = job["priority"].as_str().unwrap_or("normal");
     let attempts = job["attempts"].as_i64().unwrap_or(0) as i32;
     let max_attempts = job["max_attempts"].as_i64().unwrap_or(3) as i32;
-    
+
     let created_at = job["created_at"]
         .as_str()
         .and_then(|s| chrono::DateTime::parse_from_rfc3339(s).ok())
         .map(|dt| dt.with_timezone(&chrono::Utc))
         .unwrap_or_else(chrono::Utc::now);
-    
+
     let scheduled_at = job["scheduled_at"]
         .as_str()
         .and_then(|s| chrono::DateTime::parse_from_rfc3339(s).ok())
@@ -360,13 +366,15 @@ async fn insert_job_from_backup(pool: &DatabasePool, job: &Value) -> Result<()>
 
     match pool {
         DatabasePool::Postgres(pg_pool) => {
-            sqlx::query(r#"
+            sqlx::query(
+                r#"
                 INSERT INTO hammerwork_jobs (
                     id, queue_name, payload, status, priority, attempts, max_attempts,
                     created_at, scheduled_at
                 ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
                 ON CONFLICT (id) DO NOTHING
-            "#)
+            "#,
+            )
             .bind(id)
             .bind(queue_name)
             .bind(payload)
@@ -380,12 +388,14 @@ async fn insert_job_from_backup(pool: &DatabasePool, job: &Value) -> Result<()>
             .await?;
         }
         DatabasePool::MySQL(mysql_pool) => {
-            sqlx::query(r#"
+            sqlx::query(
+                r#"
                 INSERT IGNORE INTO hammerwork_jobs (
                     id, queue_name, payload, status, priority, attempts, max_attempts,
                     created_at, scheduled_at
                 ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-            "#)
+            "#,
+            )
             .bind(id)
             .bind(queue_name)
             .bind(payload)
@@ -399,13 +409,13 @@ async fn insert_job_from_backup(pool: &DatabasePool, job: &Value) -> Result<()>
             .await?;
         }
     }
-    
+
     Ok(())
 }
 
 async fn list_backups(path: Option<String>) -> Result<()> {
     let backup_dir = path.unwrap_or_else(|| "./backups".to_string());
-    
+
     if !std::path::Path::new(&backup_dir).exists() {
         println!("📂 No backup directory found at: {}", backup_dir);
         return Ok(());
@@ -417,15 +427,15 @@ async fn list_backups(path: Option<String>) -> Result<()> {
     for entry in entries {
         let entry = entry?;
         let path = entry.path();
-        
+
         if path.is_file() {
             if let Some(ext) = path.extension() {
                 if ext == "json" || ext == "csv" {
                     let metadata = entry.metadata()?;
                     let size = metadata.len();
                     let modified = metadata.modified()?;
                     let modified_time = chrono::DateTime::<chrono::Utc>::from(modified);
-                    
+
                     backups.push((
                         path.file_name().unwrap().to_string_lossy().to_string(),
                         size,
@@ -445,7 +455,7 @@ async fn list_backups(path: Option<String>) -> Result<()> {
 
     println!("📋 Available Backups");
     println!("════════════════════");
-    
+
     for (name, size, modified) in backups {
         let size_str = if size > 1024 * 1024 {
             format!("{:.1} MB", size as f64 / (1024.0 * 1024.0))
@@ -454,9 +464,14 @@ async fn list_backups(path: Option<String>) -> Result<()> {
         } else {
             format!("{} bytes", size)
         };
-        
-        println!("📄 {} ({}) - {}", name, size_str, modified.format("%Y-%m-%d %H:%M:%S UTC"));
+
+        println!(
+            "📄 {} ({}) - {}",
+            name,
+            size_str,
+            modified.format("%Y-%m-%d %H:%M:%S UTC")
+        );
     }
 
     Ok(())
-}
+}

cargo-hammerwork/src/commands/batch.rs

@@ -217,7 +217,10 @@ async fn batch_enqueue(
                 total_errors += 1;
                 eprintln!("❌ Line {}: Invalid JSON - {}", line_num + 1, e);
                 if !continue_on_error {
-                    return Err(anyhow::anyhow!("JSON parsing failed at line {}", line_num + 1));
+                    return Err(anyhow::anyhow!(
+                        "JSON parsing failed at line {}",
+                        line_num + 1
+                    ));
                 }
                 continue;
             }
@@ -261,22 +264,32 @@ async fn batch_enqueue(
         println!("Total errors: {}", total_errors);
     }
 
-    info!("Batch enqueue completed: {} processed, {} errors", total_processed, total_errors);
+    info!(
+        "Batch enqueue completed: {} processed, {} errors",
+        total_processed, total_errors
+    );
     Ok(())
 }
 
-async fn insert_single_job(pool: &DatabasePool, queue: &str, payload: &Value, priority: &str) -> Result<()> {
+async fn insert_single_job(
+    pool: &DatabasePool,
+    queue: &str,
+    payload: &Value,
+    priority: &str,
+) -> Result<()> {
     let job_id = uuid::Uuid::new_v4().to_string();
     let now = chrono::Utc::now();
 
     match pool {
         DatabasePool::Postgres(pg_pool) => {
-            sqlx::query(r#"
+            sqlx::query(
+                r#"
                 INSERT INTO hammerwork_jobs (
                     id, queue_name, payload, status, priority, attempts, max_attempts,
                     created_at, scheduled_at
                 ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
-            "#)
+            "#,
+            )
             .bind(&job_id)
             .bind(queue)
             .bind(payload)
@@ -290,12 +303,14 @@ async fn insert_single_job(pool: &DatabasePool, queue: &str, payload: &Value, pr
             .await?;
         }
         DatabasePool::MySQL(mysql_pool) => {
-            sqlx::query(r#"
+            sqlx::query(
+                r#"
                 INSERT INTO hammerwork_jobs (
                     id, queue_name, payload, status, priority, attempts, max_attempts,
                     created_at, scheduled_at
                 ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-            "#)
+            "#,
+            )
             .bind(&job_id)
             .bind(queue)
             .bind(payload)
@@ -309,7 +324,7 @@ async fn insert_single_job(pool: &DatabasePool, queue: &str, payload: &Value, pr
             .await?;
         }
     }
-    
+
     Ok(())
 }
 
@@ -323,27 +338,36 @@ async fn batch_retry(
     dry_run: bool,
 ) -> Result<()> {
     if !confirm && !dry_run {
-        println!("⚠️  This will retry multiple jobs. Use --confirm to proceed or --dry-run to preview.");
+        println!(
+            "⚠️  This will retry multiple jobs. Use --confirm to proceed or --dry-run to preview."
+        );
         return Ok(());
     }
 
     // Build filter conditions
     let mut conditions = Vec::new();
-    
+
     if let Some(queue_name) = &queue {
         conditions.push(format!("queue_name = '{}'", queue_name));
     }
-    
+
     match status.as_deref() {
         Some("failed") => conditions.push("status = 'Failed'".to_string()),
         Some("dead") => conditions.push("status = 'Dead'".to_string()),
         None => conditions.push("status IN ('Failed', 'Dead')".to_string()),
-        _ => return Err(anyhow::anyhow!("Invalid status filter. Use 'failed' or 'dead'")),
+        _ => {
+            return Err(anyhow::anyhow!(
+                "Invalid status filter. Use 'failed' or 'dead'"
+            ));
+        }
     }
 
     if let Some(hours) = failed_since_hours {
         let cutoff = chrono::Utc::now() - chrono::Duration::hours(hours as i64);
-        conditions.push(format!("failed_at > '{}'", cutoff.format("%Y-%m-%d %H:%M:%S")));
+        conditions.push(format!(
+            "failed_at > '{}'",
+            cutoff.format("%Y-%m-%d %H:%M:%S")
+        ));
     }
 
     if max_attempts_reached {
@@ -357,7 +381,10 @@ async fn batch_retry(
     };
 
     // Count jobs to retry
-    let count_query = format!("SELECT COUNT(*) as count FROM hammerwork_jobs WHERE {}", where_clause);
+    let count_query = format!(
+        "SELECT COUNT(*) as count FROM hammerwork_jobs WHERE {}",
+        where_clause
+    );
     let job_count = execute_count_query(&pool, &count_query).await?;
 
     println!("🔄 Batch Retry Analysis");
@@ -406,27 +433,36 @@ async fn batch_cancel(
     dry_run: bool,
 ) -> Result<()> {
     if !confirm && !dry_run {
-        println!("⚠️  This will cancel multiple jobs. Use --confirm to proceed or --dry-run to preview.");
+        println!(
+            "⚠️  This will cancel multiple jobs. Use --confirm to proceed or --dry-run to preview."
+        );
         return Ok(());
     }
 
     // Build filter conditions
     let mut conditions = Vec::new();
-    
+
     if let Some(queue_name) = &queue {
         conditions.push(format!("queue_name = '{}'", queue_name));
     }
-    
+
     match status.as_deref() {
         Some("pending") => conditions.push("status = 'Pending'".to_string()),
         Some("running") => conditions.push("status = 'Running'".to_string()),
         None => conditions.push("status IN ('Pending', 'Running')".to_string()),
-        _ => return Err(anyhow::anyhow!("Invalid status filter. Use 'pending' or 'running'")),
+        _ => {
+            return Err(anyhow::anyhow!(
+                "Invalid status filter. Use 'pending' or 'running'"
+            ));
+        }
     }
 
     if let Some(hours) = older_than_hours {
         let cutoff = chrono::Utc::now() - chrono::Duration::hours(hours as i64);
-        conditions.push(format!("created_at < '{}'", cutoff.format("%Y-%m-%d %H:%M:%S")));
+        conditions.push(format!(
+            "created_at < '{}'",
+            cutoff.format("%Y-%m-%d %H:%M:%S")
+        ));
     }
 
     let where_clause = if conditions.is_empty() {
@@ -436,7 +472,10 @@ async fn batch_cancel(
     };
 
     // Count jobs to cancel
-    let count_query = format!("SELECT COUNT(*) as count FROM hammerwork_jobs WHERE {}", where_clause);
+    let count_query = format!(
+        "SELECT COUNT(*) as count FROM hammerwork_jobs WHERE {}",
+        where_clause
+    );
     let job_count = execute_count_query(&pool, &count_query).await?;
 
     println!("🚫 Batch Cancel Analysis");
@@ -463,4 +502,4 @@ async fn batch_cancel(
     println!("   Cancelled {} jobs", deleted);
 
     Ok(())
-}
+}