#[non_exhaustive]pub enum Response {
Show 26 variants
Pong,
Flock(Vec<ProcessInfo>),
Described(Vec<ProcessInfo>),
Started(Vec<ProcessInfo>),
Added(Vec<ProcessInfo>),
Drifted(Vec<SheepDrift>),
Applied(Vec<SheepApplied>),
Stopped(Vec<ProcessInfo>),
Restarted(Vec<ProcessInfo>),
Reloading(Vec<ProcessInfo>),
Scaled(Vec<ProcessInfo>),
SmitPainted(Vec<ProcessInfo>),
Deleted(Vec<u32>),
Reopened(Vec<ProcessInfo>),
Flushed(Vec<ProcessInfo>),
Triggered(Vec<ActionReply>),
Signalled(Vec<SignalReply>),
SentLine(Vec<LineReply>),
RollSaved {
path: String,
apps: u32,
},
Mustered(Vec<ProcessInfo>),
DogSection {
toml: DogSectionToml,
},
DogStarted(ProcessInfo),
DogStaleness {
stale: Vec<String>,
pending: Vec<String>,
},
HandoverFitness {
refusal: Option<String>,
},
Subscribed,
ShuttingDown,
}Expand description
One RPC response (pairs with Request variants)
Ten variants carry a bare Vec<ProcessInfo> (Flock, Described,
Started, Stopped, Restarted, Reloading, Scaled, Reopened,
Flushed, Mustered), and that repetition is intentional — do not
collapse them into one. Each names which request it answers, which is what
lets a variant diverge later without a protocol bump: Reloading already
means an acceptance rather than a result, Scaled already means only the
survivors on a scale-down rather than every matched row, and Mustered
already means “every sheep of every restored app” rather than “what this
call started”. A single Listing(Vec<ProcessInfo>) would have to
relitigate all three as a breaking change.
Variants (Non-exhaustive)§
This enum is marked as non-exhaustive
Pong
Answer to Ping
Flock(Vec<ProcessInfo>)
Answer to ListFlock
Described(Vec<ProcessInfo>)
Answer to Describe
Started(Vec<ProcessInfo>)
Answer to Start
Added(Vec<ProcessInfo>)
Answer to Add: one row per app the request named, registered and
spawning nothing.
A row here can still be Online. Add is idempotent by name, so an
app the flock already had is answered as it stands rather than
replaced. The reply describes the membership the request leaves
behind, not work it did.
Drifted(Vec<SheepDrift>)
Answer to ConfigDrift: one entry per app that is registered under a
config different from the one asked about, and no entry for anything
else. An empty vector means every app asked about either matches or
is not registered at all.
Applied(Vec<SheepApplied>)
Answer to ApplyConfig: one entry per app the request named, in the
order it named them, including the apps that were refused and the
apps that had nothing to change.
Complete where Self::Drifted is filtered, and the difference is
deliberate. A drift report answers “what is different”, so a matching
app has nothing to say; a load answers “what did you do to each of
these”, and an app missing from that answer is indistinguishable from
an app the daemon silently dropped.
Stopped(Vec<ProcessInfo>)
Answer to Stop
Restarted(Vec<ProcessInfo>)
Answer to Restart
Reloading(Vec<ProcessInfo>)
Answer to Reload — an ACCEPTANCE, not a result, and the only reply
in this enum carrying a flock listing that names one rather than
finished work. Self::ShuttingDown is an acceptance too, sent
before the daemon actually goes down, but it carries nothing.
One instance costs a readiness wait plus a drain in the worst case, so
a clustered app outlasts any deadline a client is allowed to ask for.
The daemon therefore answers as soon as the reload is accepted, with
the matched sheep as they stood at that moment, and the swaps report
themselves on the bus — process.reload, process.reloaded,
process.reload_abandoned. A matched sheep with nothing to replace is
listed here as the no-op success it is, so this carries the same
matches Describe would.
Scaled(Vec<ProcessInfo>)
Answer to Scale — the app’s instances that will REMAIN, one row
each, by name, then by instance slot, then by id (sort_flock).
Every row shares one name here, so in practice that is slot order,
with the id breaking a tie only where two rows report the same slot.
Scaling up, these are the instances that exist, the new ones included, and the answer is complete.
Scaling down, these are the survivors and the departing instances are
deliberately absent, even though they are still running their kill
ladders as this reply is written. The operator asked for a number; this
is that number of rows. Listing the departing ones as well would answer
a scale web 2 with four rows, which is the one thing the reply must
not do. The departures report themselves on the bus as process.delete
— the same split Reloading already makes between an acceptance and
the swaps that follow it.
SmitPainted(Vec<ProcessInfo>)
Answer to SetSmit — every instance of the named sheep, one row
each, each carrying the smit as it now stands.
Its own variant rather than one of the ten above, on this enum’s own
stated terms: each of them names which request it answers so that one
can diverge later without a protocol bump. A future SetSmit reply
that also reported which connection holds the mark would have nowhere
to go if this shared Scaled.
Deleted(Vec<u32>)
Answer to Delete — ids removed
Reopened(Vec<ProcessInfo>)
Answer to Reopen — every matched sheep, running or not. A sheep with
no live log pump has nothing to reopen and is reported as a success,
so this carries the same matches Describe would.
Flushed(Vec<ProcessInfo>)
Answer to Flush — one row per matched sheep, running or not, exactly
as Self::Reopened.
One row per SHEEP, not per file emptied. Several sheep can share one
log path (merge_logs, or an explicit out_file on a multi-instance
app), and the daemon truncates each distinct path once — but the
selector names sheep, so the answer names sheep, and the count here
matches what Describe would return for the same selector.
Triggered(Vec<ActionReply>)
Answer to Trigger — one ActionReply row per matched sheep,
carrying what each one answered rather than a flock listing:
ProcessInfo has nowhere to hold a reply body.
Signalled(Vec<SignalReply>)
Answer to Signal — one SignalReply row per matched sheep.
Not a flock listing: what a caller wants back is per-instance delivery,
and ProcessInfo has nowhere to hold it. Same reasoning, and the
same row-shaped answer, as Self::Triggered.
SentLine(Vec<LineReply>)
Answer to SendLine — one LineReply row per matched sheep.
RollSaved
Answer to SaveRoll
Fields
Mustered(Vec<ProcessInfo>)
Answer to Muster — every sheep of every app the roll restored, not
only the ones this call spawned.
The distinction is the whole point of the reply. Assembling a flock that is already assembled starts nothing, so a listing of what this call spawned would be empty there — indistinguishable from an empty roll, which is the one outcome an operator needs to tell apart.
DogSection
Answer to DogConfig — the dog’s own section, rendered back to TOML.
toml is DogSectionToml, not a bare String: this text
routinely carries webhook credentials, and the newtype’s manual
Debug keeps them out of a {:?}-formatted Response — see that
type’s docs for why the section travels over the socket at all.
Fields
toml: DogSectionTomlThe [dog.<name>] table as TOML text, empty when the file has
no such section
DogStarted(ProcessInfo)
Answer to EnableDog — the dog as it stands now
DogStaleness
Answer to DogStaleness — this daemon’s own handshake record, split
into the dogs it has given up on and the dogs it is still waiting on.
Two lists rather than one because they are answers to two different
questions, and only one of them is reportable. stale is a
finding: those dogs were refused, restarted from the binary on disk,
and refused again. pending is a reason to ask again: those
dogs have not finished settling, so a reading taken now would be a
guess about them rather than a fact.
Names only. What a stale dog’s crate version is does not answer the question a caller is asking — two builds differing only in the protocol they speak report the same version — so carrying one here would invite exactly the inference it cannot support.
Fields
HandoverFitness
Answer to HandoverFitness: None when the whole flock can be
carried across a daemon handover, and otherwise the sentence saying
which sheep cannot be and why.
A rendered sentence rather than a structured reason, deliberately. The set of things a handover cannot yet carry is exactly the set of things that phase has not built, so it changes with every phase that widens it, and a wire enum would make each of those a protocol change for a string the client does nothing with but print. The daemon owns the wording because the daemon owns the gate.
Subscribed
Answer to Subscribe
ShuttingDown
Answer to KillDaemon