use bytes::Bytes;
use shep_core::permissions::{Grants, Need, Permission, need};
use shep_core::protocol::{Request, RpcError, RpcErrorCode};
use shep_core::selector::ProcessSelector;
use tokio::sync::mpsc;
use tokio::task::JoinHandle;
use super::context::RpcContext;
use super::error::rpc_error;
use super::selector_verbs::matching_rows;
use crate::bus::{TopicFilter, spawn_forwarder, spawn_guarded_forwarder};
pub(super) async fn check(ctx: &RpcContext, dog: &str, request: &Request) -> Result<(), RpcError> {
let Some(grants) = ctx.known_dogs.grants(dog) else {
return Ok(());
};
let refuse = |needed: &str| forbidden(dog, request, needed);
match need(request, dog) {
Need::Always => Ok(()),
Need::Permission(permission) => require(&grants, &permission).map_err(|p| refuse(&p)),
Need::Selector {
selector,
sheep,
dog: for_dog,
} => {
let Ok(selector) = ProcessSelector::try_from(selector.clone()) else {
return Ok(());
};
let infos = ctx
.supervisor
.list_checked()
.await
.map_err(|err| rpc_error(&err))?;
let mut reached = matching_rows(infos, &selector)
.into_iter()
.map(|i| {
if i.dog.is_some() {
for_dog(&i.name)
} else {
sheep.clone()
}
})
.peekable();
if reached.peek().is_none() {
return require(&grants, &sheep).map_err(|p| refuse(&p));
}
reached.try_for_each(|p| require(&grants, &p).map_err(|p| refuse(&p)))
}
Need::Topics(topics) => topics
.iter()
.find(|topic| !grants.allows_topic(topic) && !is_own_config_topic(topic, dog))
.map_or(Ok(()), |topic| {
Err(refuse(&format!("events:{}", literal_head(topic))))
}),
Need::ResolvedRead { sheep, dog: table } => {
let read = ctx
.supervisor
.sheep_dog_read(sheep.to_string(), table.to_string())
.await
.map_err(|err| rpc_error(&err))?;
let Some(read) = read else { return Ok(()) };
require(&grants, &Permission::SecretsRead(read.environment)).map_err(|p| refuse(&p))
}
_ => Err(refuse("a permission this shepherd does not know")),
}
}
pub(super) fn pin_grants(ctx: &RpcContext, request: Request) -> Request {
match request {
Request::EnableDog { name, source, env } => {
let recorded = ctx
.known_dogs
.recorded(&name)
.unwrap_or_else(|| Some(Grants::default()));
Request::EnableDog {
source: source.with_grants(recorded),
name,
env,
}
}
other => other,
}
}
pub(crate) async fn check_carried(
ctx: &RpcContext,
dog: &str,
topics: &[String],
) -> Result<(), RpcError> {
check(
ctx,
dog,
&Request::Subscribe {
topics: topics.to_vec(),
},
)
.await
}
pub(crate) fn spawn_checked_forwarder(
ctx: &RpcContext,
dog: Option<&str>,
filter: TopicFilter,
out: mpsc::Sender<Bytes>,
) -> JoinHandle<()> {
let Some(dog) = dog else {
return spawn_forwarder(&ctx.events, filter, out);
};
let (known_dogs, dog) = (ctx.known_dogs.clone(), dog.to_owned());
let topics = filter.patterns().to_vec();
spawn_guarded_forwarder(&ctx.events, filter, out, move || {
known_dogs.grants(&dog).is_none_or(|grants| {
topics
.iter()
.all(|topic| grants.allows_topic(topic) || is_own_config_topic(topic, &dog))
})
})
}
fn require(grants: &Grants, permission: &Permission) -> Result<(), String> {
if grants.allows(permission) {
Ok(())
} else {
Err(permission.to_string())
}
}
fn is_own_config_topic(topic: &str, dog: &str) -> bool {
topic
.strip_prefix("config.dog.")
.or_else(|| topic.strip_prefix("config.sheep."))
== Some(dog)
}
pub(crate) fn kind_of(request: &Request) -> String {
serde_json::to_value(request)
.ok()
.and_then(|value| value.get("kind")?.as_str().map(str::to_owned))
.unwrap_or_else(|| "request".to_owned())
}
fn literal_head(pattern: &str) -> &str {
pattern
.find(['*', '?', '[', '{', '\\'])
.map_or(pattern, |at| &pattern[..at])
}
fn forbidden(dog: &str, request: &Request, needed: &str) -> RpcError {
RpcError {
code: RpcErrorCode::Forbidden,
message: format!(
"dog `{dog}` was refused `{}`: it needs `{needed}`, which was not granted to it",
kind_of(request)
),
daemon_version: None,
}
}