Struct SheepApplied 

#[non_exhaustive]
pub struct SheepApplied {
    pub name: String,
    pub applied: Vec<String>,
    pub pending: Vec<String>,
    pub refused: Option<String>,
}

What one app’s Request::ApplyConfig did: the answer a load owes the operator who ran it

One of these per app the request named, whether or not the app was found and whether or not anything about it changed. A load that quietly skipped an app would leave an operator reading a Flockfile that says one thing and a flock doing another, which is the failure this whole verb exists to fix.

Self::applied and Self::pending carry field NAMES only, never their values, exactly as SheepDrift carries them and for the same reason: this is built to be printed at an operator, and AppConfig::env carries secrets, so an applied env reports "env" and nothing more (IR-41). The merged config itself never reaches a client at all – the daemon keeps it, because a config is not something a client needs and env is in it.

Self::refused is prose and is deliberately not held to that, so the rule above is scoped to the two lists rather than stated of the whole type. A refusal is a sentence an operator reads, and the useful ones name the thing that was refused: the daemon’s own instance-count refusal quotes the count the file asked for, and a rejected {{...}} template quotes the offending fragment. Those are values out of the FILE the caller just sent, not values out of the flock’s stored config, which is what makes them safe to echo; see that field’s own doc. A refusal that needs to name an env value is one the daemon must word differently, not one this type can prevent.

Debug is derived on that basis: refused holds only what the daemon chose to put in front of an operator anyway, so there is nothing here to redact that redacting would help.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

name: String

The sheep’s name, exactly as the request spelled it.

applied: Vec<String>

Fields now in force, in field-name order. Empty when the load changed nothing the daemon could act on immediately.

pending: Vec<String>

Fields the app picks up at its next spawn, in field-name order. Empty when nothing is waiting.

shep reload <name> is what promotes them; a client rendering this list says so, because a pending list with no remedy beside it is a report nobody can act on.

refused: Option<String>

Why some or all of this app’s change did not land, in the daemon’s own words, or None when the whole of it did.

Not the same question as the two lists being empty. A refusal raised before anything was touched leaves both empty, and so does a load with nothing to do; a refusal raised after the flock was already reshaped arrives beside lists that carry what did land. The message is what tells them apart, which is why it is a sentence rather than a code.

Implementations

impl SheepApplied

pub fn new( name: impl Into<String>, applied: Vec<String>, pending: Vec<String>, refused: Option<String>, ) -> Self

Builds one app’s report.

No builder, matching SheepDrift::new: all four fields are required and none can be defaulted to something honest, so there is no optional surface for one to spare a caller.

Trait Implementations

impl Clone for SheepApplied

fn clone(&self) -> SheepApplied

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SheepApplied

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SheepApplied

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for SheepApplied

impl PartialEq for SheepApplied

fn eq(&self, other: &SheepApplied) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for SheepApplied

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SheepApplied