Struct IncomingSessionPixConfig 

pub struct IncomingSessionPixConfig {
    pub enforce_pix: bool,
    pub quota_range: RangeInclusive<u64>,
    pub max_live_cycle_bytes: u64,
    pub supervision: SupervisorConfig,
}

Configuration of the PIX protocol for incoming Sessions on Exit nodes.

Fields

enforce_pix: bool

If set to true, incoming Session without the Capability::UsePIX will be rejected.

Default false.

quota_range: RangeInclusive<u64>

Acceptable range of data quota in bytes.

With dynamic SSA batches enabled, the Exit selects the smallest batch up to SupervisorConfig::ssas_per_request whose total batch_size × quota_per_ssa is inside this range. With dynamic batches disabled, the Entry’s per-SSA quota itself must be inside the range and the configured batch size is used exactly. An offer that satisfies neither rule is rejected before the Session is established.

The default is derived from the default PIX dimensions (crate::DEFAULT_PIX_POLYS_PER_SSA × (crate::DEFAULT_PIX_SHARES_PER_POLY + crate::DEFAULT_PIX_SURPLUS_SHARES)) rather than hard-coded, so that an Entry running the default configuration is always accepted. The upper bound is exactly DEFAULT_PIX_SSA_QUOTA. Since every dynamic batch has at least one member, that upper bound still caps the data served by any one SSA cycle. Accepting larger dimensions would raise both that exposure and the reconstructor memory held per Session, so an Exit that wants to serve them must widen this range explicitly.

The quota it is compared against counts the surplus — polys × (threshold + surplus) × PIX_QUOTA_BYTES_PER_SHARE — so this bounds the traffic actually served rather than the fraction of it the threshold accounts for. It used to bound only the latter, which understated the exposure by the surplus factor: 1.25× at the deployed dimensions.

Defaults to DEFAULT_PIX_SSA_QUOTA / 4 ..= DEFAULT_PIX_SSA_QUOTA (≈ 227 MiB to ≈ 908 MiB, inclusive).

max_live_cycle_bytes: u64

Ceiling on the live Exit-side reconstructor state this node will commit to, in bytes.

This, not SessionManagerConfig::maximum_sessions, is what bounds reconstructor memory. A PIX Session reserves MAX_OVERLAPPING_BATCHES × ssas_per_request × hopr_protocol_pix::peak_cycle_bytes(offered params) when it is accepted and holds it until it closes; a Session that does not fit is refused with StartErrorReason::NoSlotsAvailable before any state is allocated for it. The reservation is computed from the parameters the peer offered, so a Session asking for smaller dimensions costs proportionally less of the budget.

Enforced at admission rather than validated as a product of the configuration, for the reason SsaReconstructorConfig::max_ack_buffer_bytes gives: maximum_sessions validates to 100 000, and the resulting product is a number no node could hold, so validating it would only ever reject the shipping defaults. Counting what has actually been committed to is indifferent to how the ceiling was configured.

Default is 3 GiB. Derived from the deployed operating point rather than picked: at the default dimensions a Session reserves ≈82 MiB, so this admits ≈37 concurrent PIX Sessions, comfortably covering the 10–30 clients per Exit the calibration profile models. The same defaults with maximum_sessions = 100 and no budget imply ≈8 GiB.

A ceiling on reservations, not an allocation: nothing is claimed up front, and because the reservation is denominated at the adversarial peak, a node serving conforming peers holds an order of magnitude less than it has reserved. The number exists to stop an Exit selling more service than its memory can hold, not to describe what it will typically use.

supervision: SupervisorConfig

Deadlines, fault limits and service budget the Exit-side PIX supervisor enforces on a Session.

These live together rather than spread across this struct because they are only meaningful as a set: crate::validate_pix_supervision checks them against each other and against the reconstructor’s lifetimes, and the node’s config validator runs that at load time.

Implementations

impl IncomingSessionPixConfig

fn effective_for( &self, decision: &SessionAdmissionDecision, ) -> EffectivePixAdmission

The terms one Session is judged on, once the session server has had its say.

The configured quota_range is an envelope, not a default: it is what validate_incoming_session_pix_config checked the deadlines and memory ceiling against, and what start_protocol_channel_capacity sized a preallocated ring from, both once at startup. So a decision’s range is intersected with it rather than replacing it — a Session may be held to less than the node advertises, never to more than it was configured to honour. An operator wanting a wider class configures a wider envelope and narrows the rest.

enforce_pix carries no such coupling and is simply overridden.

pub fn supervisor_config(&self) -> SupervisorConfig

The supervisor configuration for Sessions accepted under these settings.

Trait Implementations

impl Clone for IncomingSessionPixConfig

fn clone(&self) -> IncomingSessionPixConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IncomingSessionPixConfig

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

Formats the value using the given formatter.

impl Default for IncomingSessionPixConfig

fn default() -> Self

Return IncomingSessionPixConfig { enforce_pix: false, quota_range: DEFAULT_PIX_SSA_QUOTA / DEFAULT_PIX_QUOTA_RANGE_SPAN ..= DEFAULT_PIX_SSA_QUOTA, max_live_cycle_bytes: 3 * 1024 * 1024 * 1024, supervision: Default::default() }

impl<'de> Deserialize<'de> for IncomingSessionPixConfig

where IncomingSessionPixConfig: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for IncomingSessionPixConfig

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for IncomingSessionPixConfig

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 IncomingSessionPixConfig