use aws_sdk_eventbridge::Client;
use aws_sdk_eventbridge::types::PutEventsRequestEntry;
use crate::{Deadline, RuntimeError};
pub const MAX_ENTRIES: usize = 10;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct EventRoute {
pub source: &'static str,
pub detail_type: &'static str,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum EntryOutcome {
Accepted(String),
Rejected {
code: String,
message: String,
},
Unknown,
}
impl EntryOutcome {
#[must_use]
pub fn is_accepted(&self) -> bool {
matches!(self, Self::Accepted(_))
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct PublishOutcome {
pub entries: Vec<EntryOutcome>,
}
impl PublishOutcome {
#[must_use]
pub fn all_accepted(&self) -> bool {
self.entries.iter().all(EntryOutcome::is_accepted)
}
#[must_use]
pub fn failed_indices(&self) -> Vec<usize> {
self.entries
.iter()
.enumerate()
.filter(|(_, outcome)| !outcome.is_accepted())
.map(|(index, _)| index)
.collect()
}
}
pub async fn publish<T: serde::Serialize>(
client: &Client,
bus: &str,
route: &EventRoute,
detail: &T,
deadline: Deadline,
) -> Result<PublishOutcome, RuntimeError> {
publish_batch(client, bus, route, std::slice::from_ref(detail), deadline).await
}
pub async fn publish_batch<T: serde::Serialize>(
client: &Client,
bus: &str,
route: &EventRoute,
details: &[T],
deadline: Deadline,
) -> Result<PublishOutcome, RuntimeError> {
if details.len() > MAX_ENTRIES {
return Err(RuntimeError::LimitExceeded {
kind: "event entries",
limit: MAX_ENTRIES as u64,
});
}
if details.is_empty() {
return Ok(PublishOutcome {
entries: Vec::new(),
});
}
let mut entries = Vec::with_capacity(details.len());
for detail in details {
let json = serde_json::to_string(detail)
.map_err(|error| RuntimeError::other("serializing an event detail", error))?;
entries.push(
PutEventsRequestEntry::builder()
.event_bus_name(bus)
.source(route.source)
.detail_type(route.detail_type)
.detail(json)
.build(),
);
}
let request = client.put_events().set_entries(Some(entries)).send();
let response = match deadline.run(request).await {
Err(_) => {
return Ok(PublishOutcome {
entries: vec![EntryOutcome::Unknown; details.len()],
});
}
Ok(Err(error)) => return Err(RuntimeError::other(format!("publishing to {bus}"), error)),
Ok(Ok(response)) => response,
};
let results = response.entries.unwrap_or_default();
let outcomes = (0..details.len())
.map(|index| match results.get(index) {
Some(result) => match (result.event_id(), result.error_code()) {
(Some(id), None) => EntryOutcome::Accepted(id.to_owned()),
(_, Some(code)) => EntryOutcome::Rejected {
code: code.to_owned(),
message: result.error_message().unwrap_or_default().to_owned(),
},
(None, None) => EntryOutcome::Unknown,
},
None => EntryOutcome::Unknown,
})
.collect();
Ok(PublishOutcome { entries: outcomes })
}