admin/on_call: Convert Event::send() to async fn (#9581)

Author: Turbo87

src/admin/on_call.rs

@@ -1,6 +1,6 @@
 use anyhow::{anyhow, Result};
 use crates_io_env_vars::required_var;
-use reqwest::{blocking::Client, header, StatusCode as Status};
+use reqwest::{header, Client, StatusCode as Status};
 
 #[derive(serde::Serialize, Debug)]
 #[serde(rename_all = "snake_case", tag = "event_type")]
@@ -25,7 +25,7 @@ impl Event {
     ///
     /// If the variant is `Trigger`, this will page whoever is on call
     /// (potentially waking them up at 3 AM).
-    pub fn send(self) -> Result<()> {
+    pub async fn send(self) -> Result<()> {
         let api_token = required_var("PAGERDUTY_API_TOKEN")?;
         let service_key = required_var("PAGERDUTY_INTEGRATION_KEY")?;
 
@@ -37,12 +37,13 @@ impl Event {
                 service_key,
                 event: self,
             })
-            .send()?;
+            .send()
+            .await?;
 
         match response.status() {
             s if s.is_success() => Ok(()),
             Status::BAD_REQUEST => {
-                let error = response.json::<InvalidEvent>()?;
+                let error = response.json::<InvalidEvent>().await?;
                 Err(anyhow!("pagerduty error: {:?}", error))
             }
             Status::FORBIDDEN => Err(anyhow!("rate limited by pagerduty")),

src/admin/test_pagerduty.rs

@@ -2,7 +2,6 @@ use anyhow::Result;
 use std::str::FromStr;
 
 use crate::admin::on_call;
-use crate::tasks::spawn_blocking;
 
 #[derive(Debug, Copy, Clone, clap::ValueEnum)]
 pub enum EventType {
@@ -33,22 +32,19 @@ pub struct Opts {
 }
 
 pub async fn run(opts: Opts) -> Result<()> {
-    spawn_blocking(move || {
-        let event = match opts.event_type {
-            EventType::Trigger => on_call::Event::Trigger {
-                incident_key: Some("test".into()),
-                description: opts.description.unwrap_or_else(|| "Test event".into()),
-            },
-            EventType::Acknowledge => on_call::Event::Acknowledge {
-                incident_key: "test".into(),
-                description: opts.description,
-            },
-            EventType::Resolve => on_call::Event::Resolve {
-                incident_key: "test".into(),
-                description: opts.description,
-            },
-        };
-        event.send()
-    })
-    .await
+    let event = match opts.event_type {
+        EventType::Trigger => on_call::Event::Trigger {
+            incident_key: Some("test".into()),
+            description: opts.description.unwrap_or_else(|| "Test event".into()),
+        },
+        EventType::Acknowledge => on_call::Event::Acknowledge {
+            incident_key: "test".into(),
+            description: opts.description,
+        },
+        EventType::Resolve => on_call::Event::Resolve {
+            incident_key: "test".into(),
+            description: opts.description,
+        },
+    };
+    event.send().await
 }

src/bin/monitor.rs

@@ -5,7 +5,6 @@
 //!     cargo run --bin monitor
 
 use anyhow::Result;
-use crates_io::tasks::spawn_blocking;
 use crates_io::worker::jobs;
 use crates_io::{admin::on_call, db, schema::*};
 use crates_io_env_vars::{var, var_parsed};
@@ -67,7 +66,7 @@ async fn check_failing_background_jobs(conn: &mut AsyncPgConnection) -> Result<(
         }
     };
 
-    spawn_blocking(move || log_and_trigger_event(event)).await?;
+    log_and_trigger_event(event).await?;
 
     Ok(())
 }
@@ -94,21 +93,17 @@ async fn check_stalled_update_downloads(conn: &mut AsyncPgConnection) -> Result<
         let minutes = Utc::now().signed_duration_since(start_time).num_minutes();
 
         if minutes > max_job_time {
-            return spawn_blocking(move || {
-                log_and_trigger_event(on_call::Event::Trigger {
-                    incident_key: Some(EVENT_KEY.into()),
-                    description: format!("update_downloads job running for {minutes} minutes"),
-                })
+            return log_and_trigger_event(on_call::Event::Trigger {
+                incident_key: Some(EVENT_KEY.into()),
+                description: format!("update_downloads job running for {minutes} minutes"),
             })
             .await;
         }
     };
 
-    spawn_blocking(move || {
-        log_and_trigger_event(on_call::Event::Resolve {
-            incident_key: EVENT_KEY.into(),
-            description: Some("No stalled update_downloads job".into()),
-        })
+    log_and_trigger_event(on_call::Event::Resolve {
+        incident_key: EVENT_KEY.into(),
+        description: Some("No stalled update_downloads job".into()),
     })
     .await
 }
@@ -152,11 +147,11 @@ async fn check_spam_attack(conn: &mut AsyncPgConnection) -> Result<()> {
         }
     };
 
-    spawn_blocking(move || log_and_trigger_event(event)).await?;
+    log_and_trigger_event(event).await?;
     Ok(())
 }
 
-fn log_and_trigger_event(event: on_call::Event) -> Result<()> {
+async fn log_and_trigger_event(event: on_call::Event) -> Result<()> {
     match event {
         on_call::Event::Trigger {
             ref description, ..
@@ -167,5 +162,5 @@ fn log_and_trigger_event(event: on_call::Event) -> Result<()> {
         } => println!("{description}"),
         _ => {} // noop
     }
-    event.send()
+    event.send().await
 }