Struct IngressEdge 

pub struct IngressEdge {
    pub provider: IngressProvider,
    pub machines: Vec<String>,
    pub slots: Vec<String>,
    pub hostnames: Vec<String>,
    pub tunnel_id: Option<String>,
    pub provider_id: Option<String>,
}

One declared edge: a front door, the slots it fronts, and the nodes it is placed on (W305 F2).

A mirror declares a list of these, which is what lets one service mix front doors — cloudflare for the public web tier, passway for an internal or high-throughput one. Before this, MirrorConfig::ingress was a single IngressProvider, so a mirror could swap front doors but never mix them.

[[ingress]]
provider = "passway"
machines = ["us-east-001", "us-south-001"]
slots    = ["bundle"]

[[ingress]]
provider  = "cloudflare-tunnel"
hostnames = ["issues.yah.dev"]

The per-node appliance is derived from this, never declared beside it. An edge does invoke a cloudflared or passway process on a box, but that is a consequence of the service’s declaration: collate_front_doors walks every service and derives what each node must run. Declaring it node-side too is what produces two sources of truth for one fact.

Fields

provider: IngressProvider

Which front door this edge is. IngressProvider::None is rejected at plan time — an edge that fronts with nothing is always a typo, never an intent (write no edge instead).

machines: Vec<String>

Nodes this front door is placed on — independent of where the fronted workload runs (R330-F37).

Empty falls back to the fronted slot’s own machine / machines, which is the co-located shape every mirror had before front-door placement was expressible. Listing several is what lets the ingress tier and the service tier scale independently: N front doors over ONE deployment, one rendered copy, so no cache coherence to settle.

slots: Vec<String>

Provider slot roles this edge fronts ("bundle", "compute", …).

One of the two selectors. With a single edge both may be empty, meaning “every fronted slot” — the legacy shape. With several edges a selector is mandatory on each, and the partition must be total and disjoint: a slot claimed by no edge, or by two, is an error naming it. An implicit catch-all across mixed front doors would silently publish a service through the wrong one.

hostnames: Vec<String>

Public hostnames this edge fronts — the other selector, for partitioning by what the world dials rather than by which slot serves it.

tunnel_id: Option<String>

Cloudflare Tunnel id this edge publishes through, overriding the fronting machine’s MachineConfig::cloudflared.

This is W267 Gap 3’s real fix, and it is the service side of it: a node can join two cohorts’ orange networks, and since §Granularity argues the tunnel credential is the isolation boundary, which cohort a given service fronts through is a property of the service, not of the box. MachineConfig.cloudflared stays as the per-node default (one tunnel is the common case, and the credential does live on the node), but it is no longer the only way to say it — so the node never has to enumerate cohorts.

provider_id: Option<String>

Infra provider id whose credentials this edge’s front door authenticates with — use = "cloudflare", resolved through .yah/infra/providers/<id>.toml exactly as a slot’s use is.

Same split as tunnel_id, one field over: whose Cloudflare account holds the tunnel is a property of the front door, not of the box that runs the compute. Without this the account was read off the fronted slot’s own use, which conflates two unrelated facts — and is unwritable for a slot whose compute provider is kind = "static" (a borrowed bare box: placement only, no credentials). Such a mirror had no way to name a Cloudflare account at all, short of writing use = "cloudflare" on the compute slot and lying about what runs it (R845).

None falls back to the fronted slot’s use, which is what every mirror written before this field meant.

Implementations

impl IngressEdge

pub fn all_slots(provider: IngressProvider, machines: Vec<String>) -> Self

An edge with no selector — fronts every fronted slot, legal only when it is the mirror’s only edge.

pub fn has_selector(&self) -> bool

true when this edge names which slots/hostnames it fronts.

pub fn claims(&self, slot: &str, hostname: &str) -> bool

Does this edge claim the rule derived from slot publishing hostname?

A selectorless edge claims everything; that is checked to be unambiguous (one edge only) before this is consulted.

pub fn label(&self) -> String

Human-readable identity for an error message — the provider plus whichever selector was written.

Trait Implementations

impl Clone for IngressEdge

fn clone(&self) -> IngressEdge

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IngressEdge

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IngressEdge

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for IngressEdge

impl PartialEq for IngressEdge

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for IngressEdge

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 IngressEdge