Struct RequiredSpec 

pub struct RequiredSpec {
    pub regions: Vec<String>,
    pub zones: Vec<String>,
    pub providers: Vec<String>,
    pub mesh_tags: Vec<String>,
    pub nodes: Vec<String>,
    pub memory_mb: u32,
    pub cpu_millis: u32,
    pub repel_archetype: Option<LifecycleArchetype>,
    pub requires_taint: Option<String>,
}

F16 placement constraints declared on a MirrorProviderSlot, lives under [providers.<role>] required = { regions = [...], mesh_tags = [...] } in mirrors/<env>.toml.

Hard (must-satisfy) axes, all AND-ed together:

• regions / zones / providers — membership: the machine’s region / zone / provider must be one of the listed values.
• mesh_tags — superset: the machine’s mesh_tags must contain every listed tag.
• memory_mb / cpu_millis — capacity floor (R572-F5): the machine’s allocatable budget must cover the demand. 0 = no constraint.
• repel_archetype — taint repulsion (R572-F5): the machine must not carry the taint "no-<archetype.taint_key()>" for the workload’s class. None = no repulsion check. Absolute — see Self::repel_archetype.
• requires_taint — taint affinity (R572-F5): the machine must carry this taint key (in taints or mesh_tags). None = no affinity.

These two are the only readers of MachineConfig::taints, which is what makes taint_effect’s closed vocabulary well-founded.

MachineConfig::sovereign_group is deliberately not an axis here and must not become one (W305/R742-F1). A sovereign group is a blast radius, not a filter: which quorum a box votes in says nothing about whether a workload may run on it, and a dev-group node exists precisely so dev-mode services — stateful ones included — can be scheduled onto it. Filtering on it would re-make the mistake W305 exists to undo, where one mechanism silently carried three unrelated properties.

An empty / zero / None on every axis means “no constraint on that axis”. A fully-unconstrained RequiredSpec matches every machine (see RequiredSpec::is_unconstrained).

Fields

regions: Vec<String>

zones: Vec<String>

providers: Vec<String>

mesh_tags: Vec<String>

nodes: Vec<String>

R833-F8: imperative placement — the machine must be one of these by name. Empty (the default) = no constraint, which is every pre-R833-F8 caller.

This is the one axis that is not a capability the scheduler infers. The operator typed --where=node:us-west-003, so it composes with the other axes exactly like the rest — a named node that fails the capacity floor or carries a repelling taint still does not match, and the refusal names why rather than silently placing the work somewhere else.

memory_mb: u32

R572-F5: minimum memory (MiB) the target node must have in its declared allocatable budget. 0 = no constraint. Filled by CloudConfig::admit_workload from the workload’s memory_request_mb() — its placement request, which is not the same number as the resources.memory_mb cgroup ceiling.

cpu_millis: u32

R572-F5: minimum CPU (millicores) the target node must have in its declared allocatable budget. 0 = no constraint. Filled by CloudConfig::admit_workload from the workload’s resources.cpu_millis.

repel_archetype: Option<LifecycleArchetype>

R572-F5: effective archetype of the workload being placed. The scheduler rejects any node that carries the taint "no-<archetype.taint_key()>". None = no repulsion check (backwards-compat for callers that don’t thread a spec through).

This is an absolute block, not a preference. CloudConfig::admit_workload sets it unconditionally from the workload’s effective archetype, and nothing in the tree tolerates a taint — so a workload cannot opt out of a no-<archetype> node (W305 finding 2 / R742-T4). Adding toleration means giving WorkloadSpec a tolerations list and consulting it here; until then, do not describe this as “repel-unless-tolerate”.

requires_taint: Option<String>

R572-F5: taint the workload requires the target node to carry (annotation yah.placement.requires-taint). The node must have the key in its taints list or mesh_tags. None = no affinity constraint.

Implementations

impl RequiredSpec

pub fn is_unconstrained(&self) -> bool

True when no axis carries a constraint — every machine matches.

pub fn matches(&self, machine: &MachineConfig) -> bool

Whether machine satisfies every hard axis.

• Membership axes (region/zone/provider): machine must carry the field and it must appear in the constraint list.
• mesh_tags: machine tags must be a superset of the required set.
• R572-F5 capacity floor: machine.allocatable.{memory,cpu} must cover self.{memory,cpu}. A machine with no allocatable block passes unconditionally (capacity unknown → no constraint enforced).
• R572-F5 taint repulsion: machine must not carry the taint "no-<archetype.taint_key()>" for the workload’s class. Absolute — the workload has no way to tolerate it (W305 finding 2).
• R572-F5 taint affinity: if requires_taint is set, the machine must carry that key in its taints list or mesh_tags.

Any other taint on the machine is ignored here, which is precisely why crate::validate::check_inert_taints refuses to let one be declared: it would read as a constraint and be none.

pub fn describe(&self) -> String

Human-readable summary of the constraints, for fail-loud error messages. Example: required.regions=[us-west] + required.mesh_tags=[tag:cloud-runner].

Trait Implementations

impl Clone for RequiredSpec

fn clone(&self) -> RequiredSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RequiredSpec

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

Formats the value using the given formatter.

impl Default for RequiredSpec

fn default() -> RequiredSpec

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RequiredSpec

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for RequiredSpec

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

where __S: Serializer,

Serialize this value into the given Serde serializer.