use core::future::Future;
use shep_core::protocol::{ProcessInfo, Reply, Response, RpcError, RpcErrorCode, SelectorSpec};
use shep_core::selector::ProcessSelector;
use shep_core::signals::OperatorSignal;
use crate::supervisor::SupervisorError;
use super::context::{Outcome, RpcContext};
use super::error::{invalid_config, rpc_error};
use super::lamb_signal::signal_lamb;
pub(super) fn not_found() -> RpcError {
RpcError {
code: RpcErrorCode::NotFound,
message: "selector matched no registered sheep".to_string(),
daemon_version: None,
}
}
pub(super) fn matching_rows(
infos: Vec<ProcessInfo>,
selector: &ProcessSelector,
) -> Vec<ProcessInfo> {
let exact = selector.is_exact();
infos
.into_iter()
.filter(|i| exact || i.dog.is_none())
.filter(|i| selector.matches(&i.name, i.id, i.fold.as_deref(), i.instance))
.collect()
}
pub(super) fn selector_of(spec: SelectorSpec) -> Result<ProcessSelector, RpcError> {
ProcessSelector::try_from(spec).map_err(invalid_config)
}
pub(super) async fn selector_call<F, Fut>(
id: u64,
spec: SelectorSpec,
call: F,
ok: fn(Vec<ProcessInfo>) -> Response,
) -> Outcome
where
F: FnOnce(ProcessSelector) -> Fut + Send,
Fut: Future<Output = Result<Vec<ProcessInfo>, SupervisorError>> + Send,
{
let result = match selector_of(spec) {
Ok(selector) => call(selector).await.map(ok).map_err(|err| rpc_error(&err)),
Err(err) => Err(err),
};
Outcome::Reply(Reply { id, result })
}
pub(super) async fn trigger(
id: u64,
spec: SelectorSpec,
action: String,
params: Option<String>,
ctx: &RpcContext,
) -> Outcome {
let result = match selector_of(spec) {
Err(err) => Err(err),
Ok(selector) => ctx
.supervisor
.trigger(selector, action, params)
.await
.map(Response::Triggered)
.map_err(|err| rpc_error(&err)),
};
Outcome::Reply(Reply { id, result })
}
pub(super) async fn signal_request(
id: u64,
spec: SelectorSpec,
signal: String,
lamb: Option<u32>,
ctx: &RpcContext,
) -> Outcome {
let result = match OperatorSignal::parse(&signal) {
None => Err(invalid_config(format!(
"`{signal}` is not a signal shep will send; accepted: {}",
OperatorSignal::ACCEPTED.join(", ")
))),
Some(sig) => match lamb {
Some(lamb) => signal_lamb(spec, sig, lamb, ctx).await,
None => match selector_of(spec) {
Err(err) => Err(err),
Ok(selector) => ctx
.supervisor
.signal(selector, sig)
.await
.map(Response::Signalled)
.map_err(|err| rpc_error(&err)),
},
},
};
Outcome::Reply(Reply { id, result })
}