use hatchet_proto::root::{RestoreEvictedTaskRequest, SubscribeToWorkflowEventsRequest};
use hatchet_proto::v1::{CancelTasksRequest, GetRunDetailsRequest, ReplayTasksRequest};
use tonic::Code;
use crate::error::{Error, Result};
use crate::runs::details::RunDetails;
use crate::runs::filter::TasksFilter;
use crate::runs::stream::{self, OutputStream};
use crate::{Client, retry};
#[derive(Clone, Debug)]
pub struct RunsClient {
client: Client,
}
impl RunsClient {
pub(crate) fn new(client: Client) -> Self {
Self { client }
}
pub async fn cancel(
&self,
ids: impl IntoIterator<Item = impl Into<String>>,
) -> Result<Vec<String>> {
let external_ids = checked_ids(ids, "cancel")?;
let request = CancelTasksRequest {
external_ids,
filter: None,
};
let response = retry::unary(|| {
let mut admin = self.client.admin_grpc();
let request = retry::timed(request.clone());
async move { admin.cancel_tasks(request).await }
})
.await?;
Ok(response.into_inner().cancelled_tasks)
}
pub async fn replay(
&self,
ids: impl IntoIterator<Item = impl Into<String>>,
) -> Result<Vec<String>> {
let external_ids = checked_ids(ids, "replay")?;
let request = ReplayTasksRequest {
external_ids,
filter: None,
};
let response = retry::unary(|| {
let mut admin = self.client.admin_grpc();
let request = retry::timed(request.clone());
async move { admin.replay_tasks(request).await }
})
.await?;
Ok(response.into_inner().replayed_tasks)
}
pub async fn cancel_matching(&self, filter: TasksFilter) -> Result<Vec<String>> {
let filter = filter.to_proto()?;
let request = CancelTasksRequest {
external_ids: Vec::new(),
filter: Some(filter),
};
let response = retry::unary(|| {
let mut admin = self.client.admin_grpc();
let request = retry::timed(request.clone());
async move { admin.cancel_tasks(request).await }
})
.await?;
Ok(response.into_inner().cancelled_tasks)
}
pub async fn replay_matching(&self, filter: TasksFilter) -> Result<Vec<String>> {
let filter = filter.to_proto()?;
let request = ReplayTasksRequest {
external_ids: Vec::new(),
filter: Some(filter),
};
let response = retry::unary(|| {
let mut admin = self.client.admin_grpc();
let request = retry::timed(request.clone());
async move { admin.replay_tasks(request).await }
})
.await?;
Ok(response.into_inner().replayed_tasks)
}
pub async fn restore_evicted(&self, task_run_id: &str) -> Result<bool> {
if task_run_id.trim().is_empty() {
return Err(Error::InvalidArgument(
"a task run id must not be blank".to_string(),
));
}
let request = RestoreEvictedTaskRequest {
task_run_external_id: task_run_id.to_string(),
};
let response = retry::unary(|| {
let mut dispatcher = self.client.dispatcher_grpc();
let request = retry::timed(request.clone());
async move { dispatcher.restore_evicted_task(request).await }
})
.await?;
Ok(response.into_inner().requeued)
}
pub async fn details(&self, run_id: &str) -> Result<RunDetails> {
if run_id.trim().is_empty() {
return Err(Error::InvalidArgument(
"a run id must not be blank".to_string(),
));
}
let request = GetRunDetailsRequest {
external_id: run_id.to_string(),
};
let response = retry::unary(|| {
let mut admin = self.client.admin_grpc();
let request = retry::timed(request.clone());
async move { admin.get_run_details(request).await }
})
.await;
let response = match response {
Ok(response) => response,
Err(status) if status.code() == Code::Unimplemented => {
return Err(self.no_run_details().await);
}
Err(status) => return Err(status.into()),
};
RunDetails::from_proto(run_id, response.into_inner())
}
pub async fn stream(&self, run_id: &str) -> Result<OutputStream> {
if run_id.trim().is_empty() {
return Err(Error::InvalidArgument(
"a run id must not be blank".to_string(),
));
}
stream::open(
&self.client,
SubscribeToWorkflowEventsRequest {
workflow_run_id: Some(run_id.to_string()),
additional_meta_key: None,
additional_meta_value: None,
},
)
.await
}
pub async fn stream_by_metadata(&self, key: &str, value: &str) -> Result<OutputStream> {
if key.trim().is_empty() || value.trim().is_empty() {
return Err(Error::InvalidArgument(format!(
"a metadata subscription needs both halves of the pair; got key {key:?} and \
value {value:?}"
)));
}
stream::open(
&self.client,
SubscribeToWorkflowEventsRequest {
workflow_run_id: None,
additional_meta_key: Some(key.to_string()),
additional_meta_value: Some(value.to_string()),
},
)
.await
}
async fn no_run_details(&self) -> Error {
let found = self
.client
.engine_version()
.await
.unwrap_or_else(|_| "unknown".to_string());
Error::UnsupportedFeature {
feature: "run details (GetRunDetails)".to_string(),
found,
minimum: crate::version::MIN_ENGINE_VERSION.to_string(),
}
}
}
fn checked_ids(
ids: impl IntoIterator<Item = impl Into<String>>,
what: &str,
) -> Result<Vec<String>> {
let ids: Vec<String> = ids.into_iter().map(Into::into).collect();
if ids.is_empty() {
return Err(Error::InvalidArgument(format!(
"{what} was given no run ids; naming none would leave it to the engine to decide \
what that means"
)));
}
if let Some(position) = ids.iter().position(|id| id.trim().is_empty()) {
return Err(Error::InvalidArgument(format!(
"{what} was given a blank run id at position {position}"
)));
}
Ok(ids)
}