make delivery list and probe APIs not webhook specific

Author: hawkw

nexus/external-api/output/nexus_tags.txt

@@ -163,15 +163,15 @@ snapshot_view                            GET      /v1/snapshots/{snapshot}
 API operations found with tag "system/alerts"
 OPERATION ID                             METHOD   URL PATH
 alert_class_list                         GET      /v1/alert-classes
-alert_delivery_list                      GET      /v1/alert-deliveries
+alert_delivery_list                      GET      /v1/alert-receivers/{receiver}/deliveries
 alert_delivery_resend                    POST     /v1/alerts/{alert_id}/resend
 alert_receiver_delete                    DELETE   /v1/alert-receivers/{receiver}
 alert_receiver_list                      GET      /v1/alert-receivers
+alert_receiver_probe                     POST     /v1/alert-receivers/{receiver}/probe
 alert_receiver_subscription_add          POST     /v1/alert-receivers/{receiver}/subscriptions
 alert_receiver_subscription_remove       DELETE   /v1/alert-receivers/{receiver}/subscriptions/{subscription}
 alert_receiver_view                      GET      /v1/alert-receivers/{receiver}
 webhook_receiver_create                  POST     /v1/webhook-receivers
-webhook_receiver_probe                   POST     /v1/webhook-receivers/{receiver}/probe
 webhook_receiver_update                  PUT      /v1/webhook-receivers/{receiver}
 webhook_secrets_add                      POST     /v1/webhook-secrets
 webhook_secrets_delete                   DELETE   /v1/webhook-secrets/{secret_id}

nexus/external-api/src/lib.rs

@@ -3623,16 +3623,50 @@ pub trait NexusExternalApi {
     /// "true" are included in the response.
     #[endpoint {
         method = GET,
-        path = "/v1/alert-deliveries",
+        path = "/v1/alert-receivers/{receiver}/deliveries",
         tags = ["system/alerts"],
     }]
     async fn alert_delivery_list(
         rqctx: RequestContext<Self::Context>,
-        receiver: Query<params::AlertReceiverSelector>,
+        path_params: Path<params::AlertReceiverSelector>,
         state_filter: Query<params::AlertDeliveryStateFilter>,
         pagination: Query<PaginatedByTimeAndId>,
     ) -> Result<HttpResponseOk<ResultsPage<views::AlertDelivery>>, HttpError>;
 
+    /// Send liveness probe to alert receiver
+    ///
+    /// This endpoint synchronously sends a liveness probe to the selected alert
+    /// receiver. The response message describes the outcome of the probe:
+    /// either the successful response (as appropriate), or indication of why
+    /// the probe failed.
+    ///
+    /// The result of the probe is represented as an `AlertDelivery` model.
+    /// Details relating to the status of the probe depend on the alert delivery
+    /// mechanism, and are included in the `AlertDeliveryAttempts` model. For
+    /// example, webhook receiver liveness probes include the HTTP status code
+    /// returned by the receiver endpoint.
+    ///
+    /// Note that the response status is `200 OK` as long as a probe request was
+    /// able to be sent to the receiver endpoint. If an HTTP-based receiver,
+    /// such as a webhook, responds to the another status code, including an
+    /// error, this will be indicated by the response body, *not* the status of
+    /// the response.
+    ///
+    /// The `resend` query parameter can be used to request re-delivery of
+    /// failed events if the liveness probe succeeds. If it is set to true and
+    /// the liveness probe succeeds, any alerts for which delivery to this
+    /// receiver has failed will be queued for re-delivery.
+    #[endpoint {
+        method = POST,
+        path = "/v1/alert-receivers/{receiver}/probe",
+        tags = ["system/alerts"],
+    }]
+    async fn alert_receiver_probe(
+        rqctx: RequestContext<Self::Context>,
+        path_params: Path<params::AlertReceiverSelector>,
+        query_params: Query<params::AlertReceiverProbe>,
+    ) -> Result<HttpResponseOk<views::AlertProbeResult>, HttpError>;
+
     /// Request re-delivery of alert
     #[endpoint {
         method = POST,
@@ -3674,34 +3708,6 @@ pub trait NexusExternalApi {
         params: TypedBody<params::WebhookReceiverUpdate>,
     ) -> Result<HttpResponseUpdatedNoContent, HttpError>;
 
-    /// Send liveness probe to webhook receiver
-    ///
-    /// This endpoint synchronously sends a liveness probe request to the
-    /// selected webhook receiver. The response message describes the outcome of
-    /// the probe request: either the response from the receiver endpoint, or an
-    /// indication of why the probe failed.
-    ///
-    /// Note that the response status is `200 OK` as long as a probe request was
-    /// able to be sent to the receiver endpoint. If the receiver responds with
-    /// another status code, including an error, this will be indicated by the
-    /// response body, *not* the status of the response.
-    ///
-    /// The `resend` query parameter can be used to request re-delivery of
-    /// failed events if the liveness probe succeeds. If it is set to true and
-    /// the webhook receiver responds to the probe request with a `2xx` status
-    /// code, any events for which delivery to this receiver has failed will be
-    /// queued for re-delivery.
-    #[endpoint {
-        method = POST,
-        path = "/v1/webhook-receivers/{receiver}/probe",
-        tags = ["system/alerts"],
-    }]
-    async fn webhook_receiver_probe(
-        rqctx: RequestContext<Self::Context>,
-        path_params: Path<params::AlertReceiverSelector>,
-        query_params: Query<params::WebhookProbe>,
-    ) -> Result<HttpResponseOk<views::WebhookProbeResult>, HttpError>;
-
     /// List webhook receiver secret IDs
     #[endpoint {
         method = GET,

nexus/src/app/webhook.rs

@@ -29,7 +29,6 @@
 
 use crate::Nexus;
 use anyhow::Context;
-use chrono::DateTime;
 use chrono::TimeDelta;
 use chrono::Utc;
 use hmac::{Hmac, Mac};
@@ -54,7 +53,6 @@ use nexus_types::external_api::views;
 use nexus_types::identity::Asset;
 use nexus_types::identity::Resource;
 use omicron_common::api::external::CreateResult;
-use omicron_common::api::external::DataPageParams;
 use omicron_common::api::external::DeleteResult;
 use omicron_common::api::external::Error;
 use omicron_common::api::external::ListResultVec;
@@ -71,7 +69,6 @@ use sha2::Sha256;
 use std::sync::LazyLock;
 use std::time::Duration;
 use std::time::Instant;
-use uuid::Uuid;
 
 impl Nexus {
     pub fn webhook_secret_lookup<'a>(
@@ -179,8 +176,8 @@ impl Nexus {
         &self,
         opctx: &OpContext,
         rx: lookup::AlertReceiver<'_>,
-        params: params::WebhookProbe,
-    ) -> Result<views::WebhookProbeResult, Error> {
+        params: params::AlertReceiverProbe,
+    ) -> Result<views::AlertProbeResult, Error> {
         let (authz_rx, rx) = rx.fetch_for(authz::Action::ListChildren).await?;
         let rx_id = authz_rx.id();
         let datastore = self.datastore();
@@ -305,7 +302,7 @@ impl Nexus {
             None
         };
 
-        Ok(views::WebhookProbeResult {
+        Ok(views::AlertProbeResult {
             probe: delivery.to_api_delivery(CLASS, &[attempt]),
             resends_started,
         })

nexus/src/external_api/http_entrypoints.rs

@@ -8032,11 +8032,11 @@ impl NexusExternalApi for NexusExternalApiImpl {
             .await
     }
 
-    async fn webhook_receiver_probe(
+    async fn alert_receiver_probe(
         rqctx: RequestContext<Self::Context>,
         path_params: Path<params::AlertReceiverSelector>,
-        query_params: Query<params::WebhookProbe>,
-    ) -> Result<HttpResponseOk<views::WebhookProbeResult>, HttpError> {
+        query_params: Query<params::AlertReceiverProbe>,
+    ) -> Result<HttpResponseOk<views::AlertProbeResult>, HttpError> {
         let apictx = rqctx.context();
         let handler = async {
             let nexus = &apictx.context.nexus;
@@ -8141,7 +8141,7 @@ impl NexusExternalApi for NexusExternalApiImpl {
 
     async fn alert_delivery_list(
         rqctx: RequestContext<Self::Context>,
-        receiver: Query<params::AlertReceiverSelector>,
+        receiver: Path<params::AlertReceiverSelector>,
         filter: Query<params::AlertDeliveryStateFilter>,
         query: Query<PaginatedByTimeAndId>,
     ) -> Result<HttpResponseOk<ResultsPage<views::AlertDelivery>>, HttpError>

nexus/tests/integration_tests/endpoints.rs

@@ -1198,18 +1198,14 @@ pub static DEMO_WEBHOOK_RECEIVER_URL: LazyLock<String> = LazyLock::new(|| {
     format!("{WEBHOOK_RECEIVERS_URL}/{}", *DEMO_WEBHOOK_RECEIVER_NAME)
 });
 
-pub static DEMO_WEBHOOK_RECEIVER_PROBE_URL: LazyLock<String> =
-    LazyLock::new(|| {
-        format!("{WEBHOOK_RECEIVERS_URL}/{}/probe", *DEMO_WEBHOOK_RECEIVER_NAME)
-    });
+pub static DEMO_ALERT_RECEIVER_PROBE_URL: LazyLock<String> =
+    LazyLock::new(|| format!("{}/probe", *DEMO_ALERT_RECEIVER_URL));
+
+pub static DEMO_ALERT_DELIVERIES_URL: LazyLock<String> =
+    LazyLock::new(|| format!("{}/deliveries", *DEMO_ALERT_RECEIVER_URL));
 
 pub static DEMO_ALERT_SUBSCRIPTIONS_URL: LazyLock<String> =
-    LazyLock::new(|| {
-        format!(
-            "{ALERT_RECEIVERS_URL}/{}/subscriptions",
-            *DEMO_WEBHOOK_RECEIVER_NAME
-        )
-    });
+    LazyLock::new(|| format!("{}/subscriptions", *DEMO_ALERT_RECEIVER_URL));
 
 pub static DEMO_ALERT_SUBSCRIPTION: LazyLock<shared::AlertSubscription> =
     LazyLock::new(|| "test.foo.**".parse().unwrap());
@@ -1223,15 +1219,11 @@ pub static DEMO_ALERT_SUBSCRIPTION_CREATE: LazyLock<
 pub static DEMO_ALERT_SUBSCRIPTION_DELETE_URL: LazyLock<String> =
     LazyLock::new(|| {
         format!(
-            "{ALERT_RECEIVERS_URL}/{}/subscriptions/{}",
-            *DEMO_WEBHOOK_RECEIVER_NAME, *DEMO_ALERT_SUBSCRIPTION,
+            "{}/subscriptions/{}",
+            *DEMO_ALERT_RECEIVER_URL, *DEMO_ALERT_SUBSCRIPTION,
         )
     });
 
-pub static DEMO_ALERT_DELIVERY_URL: LazyLock<String> = LazyLock::new(|| {
-    format!("/v1/alert-deliveries?receiver={}", *DEMO_WEBHOOK_RECEIVER_NAME)
-});
-
 pub static DEMO_WEBHOOK_SECRETS_URL: LazyLock<String> = LazyLock::new(|| {
     format!("/v1/webhook-secrets?receiver={}", *DEMO_WEBHOOK_RECEIVER_NAME)
 });
@@ -2865,7 +2857,7 @@ pub static VERIFY_ENDPOINTS: LazyLock<Vec<VerifyEndpoint>> =
                 )],
             },
             VerifyEndpoint {
-                url: &DEMO_WEBHOOK_RECEIVER_PROBE_URL,
+                url: &DEMO_ALERT_RECEIVER_PROBE_URL,
                 visibility: Visibility::Protected,
                 unprivileged_access: UnprivilegedAccess::None,
                 allowed_methods: vec![AllowedMethod::Post(
@@ -2906,7 +2898,7 @@ pub static VERIFY_ENDPOINTS: LazyLock<Vec<VerifyEndpoint>> =
                 allowed_methods: vec![AllowedMethod::Delete],
             },
             VerifyEndpoint {
-                url: &DEMO_ALERT_DELIVERY_URL,
+                url: &DEMO_ALERT_DELIVERIES_URL,
                 visibility: Visibility::Protected,
                 unprivileged_access: UnprivilegedAccess::None,
                 allowed_methods: vec![AllowedMethod::Get],

nexus/tests/integration_tests/webhooks.rs

@@ -244,7 +244,7 @@ async fn webhook_send_probe(
     webhook_id: &AlertReceiverUuid,
     resend: bool,
     status: http::StatusCode,
-) -> views::WebhookProbeResult {
+) -> views::AlertProbeResult {
     let pathparams = if resend { "?resend=true" } else { "" };
     let path =
         format!("{WEBHOOK_RECEIVERS_BASE_PATH}/{webhook_id}/probe{pathparams}");

nexus/types/src/external_api/params.rs

@@ -2536,7 +2536,7 @@ impl AlertDeliveryStateFilter {
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize, JsonSchema)]
-pub struct WebhookProbe {
+pub struct AlertReceiverProbe {
     /// If true, resend all events that have not been delivered successfully if
     /// the probe request succeeds.
     #[serde(default)]

nexus/types/src/external_api/views.rs

@@ -1415,10 +1415,10 @@ pub struct AlertDeliveryId {
     pub delivery_id: Uuid,
 }
 
-/// Data describing the result of a webhook liveness probe attempt.
+/// Data describing the result of an alert receiver liveness probe attempt.
 #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
-pub struct WebhookProbeResult {
-    /// The outcome of the probe request.
+pub struct AlertProbeResult {
+    /// The outcome of the probe delivery.
     pub probe: AlertDelivery,
     /// If the probe request succeeded, and resending failed deliveries on
     /// success was requested, the number of new delivery attempts started.