use std::collections::BTreeSet;
#[cfg(unix)]
use std::sync::Arc;
use shep_core::protocol::Request;
#[cfg(unix)]
use super::link_table::Lease;
use crate::rpc::{RpcContext, kind_of};
#[derive(Debug, Clone, Copy)]
pub(super) enum Side {
Reader,
Writer,
}
#[derive(Debug, Clone)]
pub(super) enum Origin {
Socket,
Dog {
name: String,
pid: u32,
#[cfg(unix)]
lease: Arc<Lease>,
resumed: Option<Vec<String>>,
},
}
impl Origin {
pub(super) fn dog<'a>(&'a self, claimed: Option<&'a str>) -> Option<&'a str> {
match self {
Self::Socket => claimed,
Self::Dog { name, .. } => Some(name),
}
}
pub(super) fn bound_dog(&self) -> Option<&str> {
match self {
Self::Socket => None,
Self::Dog { name, .. } => Some(name),
}
}
pub(super) fn pid(&self, reported: Option<u32>) -> Option<u32> {
match self {
Self::Socket => reported,
Self::Dog { pid, .. } => Some(*pid),
}
}
pub(super) fn resumed(&self) -> Option<&[String]> {
match self {
Self::Socket => None,
Self::Dog { resumed, .. } => resumed.as_deref(),
}
}
pub(super) async fn greeted(&self) {
#[cfg(unix)]
if let Self::Dog { lease, .. } = self {
lease.greeted().await;
}
}
#[cfg_attr(
not(unix),
allow(unused_variables, reason = "only a unix link has a row to note it on")
)]
pub(super) async fn subscribed(&self, patterns: &[String]) {
#[cfg(unix)]
if let Self::Dog { lease, .. } = self {
lease.subscribed(patterns).await;
}
}
pub(super) async fn frozen(&self) {
#[cfg(unix)]
if let Self::Dog { lease, .. } = self {
return lease.frozen().await;
}
core::future::pending::<()>().await;
}
#[cfg_attr(
not(unix),
allow(unused_variables, reason = "only a unix link has a row to park on")
)]
pub(super) async fn park(&self, side: Side) {
#[cfg(unix)]
if let Self::Dog { lease, .. } = self {
lease.park(side).await;
}
}
#[cfg(all(test, unix))]
pub(super) fn untracked_dog(name: &str, pid: u32) -> Self {
Self::Dog {
name: name.to_string(),
pid,
lease: Arc::new(Lease::untracked()),
resumed: None,
}
}
pub(super) fn contacts_on_open(&self) -> bool {
matches!(self, Self::Socket)
}
#[cfg_attr(
not(unix),
allow(dead_code, reason = "only the unix accept path checks the peer")
)]
pub(super) fn checks_peer(&self) -> bool {
matches!(self, Self::Socket)
}
}
#[derive(Debug, Default)]
pub(super) struct Attribution {
dog: Option<String>,
seen: BTreeSet<String>,
}
impl Attribution {
pub(super) fn new(origin: &Origin) -> Self {
match origin {
Origin::Socket => Self::default(),
Origin::Dog { name, .. } => Self {
dog: Some(name.clone()),
seen: BTreeSet::new(),
},
}
}
pub(super) fn note(&mut self, ctx: &RpcContext, request: &Request) {
let Some(dog) = &self.dog else { return };
let kind = kind_of(request);
if self.seen.insert(kind.clone()) {
crate::dogs::narrate_by_name(
&ctx.supervisor,
&ctx.events,
dog,
format!("this dog sent shep a `{kind}` request on its own connection"),
);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(unix)]
#[test]
fn a_link_ignores_the_name_the_peer_claims() {
let link = Origin::untracked_dog("metrics", 7);
assert_eq!(link.dog(Some("bark")), Some("metrics"));
assert_eq!(link.dog(None), Some("metrics"));
}
#[cfg(unix)]
#[test]
fn only_a_link_is_bound_by_its_dogs_grants() {
assert_eq!(
Origin::untracked_dog("metrics", 7).bound_dog(),
Some("metrics")
);
assert_eq!(Origin::Socket.bound_dog(), None);
}
#[test]
fn the_socket_takes_the_claim_as_given() {
assert_eq!(Origin::Socket.dog(Some("bark")), Some("bark"));
assert_eq!(Origin::Socket.dog(None), None);
}
#[cfg(unix)]
#[test]
fn a_link_records_contact_against_its_own_pid() {
let link = Origin::untracked_dog("metrics", 7);
assert_eq!(link.pid(Some(99)), Some(7));
assert_eq!(Origin::Socket.pid(Some(99)), Some(99));
}
#[cfg(unix)]
#[test]
fn only_the_socket_checks_its_peer() {
assert!(Origin::Socket.checks_peer());
assert!(!Origin::untracked_dog("metrics", 7).checks_peer());
}
#[test]
fn a_request_is_named_by_its_variant_alone() {
assert_eq!(kind_of(&Request::Ping), "ping");
assert_eq!(kind_of(&Request::ListFlock), "list_flock");
}
}