Struct ProxyConfig 

#[non_exhaustive]
pub struct ProxyConfig {
    pub effective: ProxyMode,
    pub sources: Vec<(ProxyConfigSource, ProxyMode)>,
    pub fallbacks: Vec<ProxyConfigSource>,
    pub captured_at: SystemTime,
}

Point-in-time system proxy snapshot.

Backend-built: sources descending precedence, effective = first (or Direct). ProxyConfig::from_ordered_sources enforces that invariant; ProxyConfig::new remains available for caller-defined resolved configurations. PartialEq ignores captured_at.

let a = ProxyConfig::from_source(ProxyConfigSource::Registry, ProxyMode::Direct);
let mut b = a.clone();
b.captured_at = SystemTime::UNIX_EPOCH;
assert_eq!(a, b);

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.

effective: ProxyMode

Resolved mode after platform precedence.

sources: Vec<(ProxyConfigSource, ProxyMode)>

Descending precedence; backend snapshots: first wins (or Direct if empty).

fallbacks: Vec<ProxyConfigSource>

Sources that were consulted, could not be read, and were left out of sources rather than failing the whole read.

A source absent from both lists was not configured; a source listed here is one the machine may well be configured with, whose value this read did not learn. That is the difference sources alone cannot express, and until this field existed the only record of it was a log line — so a consumer built without the tracing feature had none at all.

Backend snapshots only: nothing here is derived from the modes, so ProxyConfig::new and the constructors below leave it empty and ProxyConfig::with_fallbacks is what fills it in.

Unlike captured_at this is compared by PartialEq, which is what makes a watcher deliver the snapshot where a degradation appears or clears. Excluding it would be worse than merely quiet: the watcher’s equality skip keeps the snapshot it already holds, so a degradation that healed would be reported for the rest of the watcher’s life.

captured_at: SystemTime

Capture time; excluded from equality.

Implementations

impl ProxyConfig

pub fn new( effective: ProxyMode, sources: Vec<(ProxyConfigSource, ProxyMode)>, ) -> Self

Build a snapshot stamped with now.

pub fn with_fallbacks(self, fallbacks: Vec<ProxyConfigSource>) -> Self

Record the sources this read could not learn the value of.

See fallbacks. Takes the whole list rather than appending, so a backend that assembles one alongside its sources hands it over in one place.

pub fn from_ordered_sources( sources: Vec<(ProxyConfigSource, ProxyMode)>, ) -> Self

Build a snapshot from sources already ordered by descending precedence.

The first mode becomes effective; an empty list becomes ProxyMode::Direct. The source order and every losing source are preserved.

pub fn from_source(source: ProxyConfigSource, mode: ProxyMode) -> Self

Snapshot whose effective value comes from exactly one source.

pub fn direct() -> Self

“No proxy” with no sources.

pub fn source(&self, source: ProxyConfigSource) -> Option<&ProxyMode>

Mode for a specific source, if consulted.

pub fn with_env(self, env: &ProxyEnv, precedence: EnvPrecedence) -> Self

Fold the process environment into this snapshot as one more source.

The environment enters whole: one entry in sources, ranked against the OS sources rather than merged into them slot by slot. Setting only http_proxy therefore does not leave the OS’s https proxy in place — the winning source answers for every scheme, and an environment with no https entry resolves https to direct. all_proxy is how the environment covers the schemes it did not name.

What the fold does depends on the environment’s shape. ProxyEnv::is_configured separates the first shape from the other two; what separates those is whether anything was dropped, which ProxyEnv::rejected and ProxyEnv::bypass’s own rejections answer.

• Configured — it takes the rank precedence asks for. A no_proxy with no proxy variable beside it is this shape, and ProxyEnv::to_mode turns it into Direct: under BeforeSystem it does not add a bypass to the OS proxy, it outranks that proxy and every host resolves direct. The error is toward bypassing more than the caller listed, never toward proxying a host they asked to exclude.
• Present but specifying nothing — appended to sources and never made effective, so a typo cannot mask the OS. Where every *_proxy value was malformed, ProxyEnv::to_mode answers Manual and the drops come back out of source. Where instead a no_proxy lost every entry it held, to_mode answers Direct, which has nowhere to hold an exclusion list: the entry records only that the environment was there and lost something, and the text of the drop stays on ProxyEnv::bypass().rejected.
• Specifying nothing and dropping nothing — self is returned untouched. Usually that means the variables are unset, but a no_proxy that parses to no rules and no rejections (no_proxy=, no_proxy=",") lands here too: it was set, and the snapshot keeps no evidence that it was.

Being configured and having dropped something are not exclusive. no_proxy=.corp beside an http_proxy that does not parse is configured — the bypass list is the configuration — so it takes the rank, and the dropped scheme rides in with it: http then answers Error::ProxyEntryUnusable instead of falling through to the OS proxy or to direct. Silently sending the scheme whose value was typed wrong straight out is the failure this crate exists to make visible.

Fold an environment in once. A second with_env can leave a second Env entry in sources, and source answers with whichever is first — which the second environment’s shape decides as much as the precedence does.

captured_at becomes the older of the two reads, except in the third shape, where nothing is folded in: the result is only as fresh as its stalest half. effective is otherwise left alone, including where that leaves it disagreeing with sources[0].

let env = ProxyEnv::from_vars([("http_proxy", "http://env.corp:3128")]).unwrap();
let os = ProxyConfig::from_source(ProxyConfigSource::Registry, ProxyMode::Direct);

let merged = os.with_env(&env, EnvPrecedence::BeforeSystem);
assert!(matches!(merged.effective, ProxyMode::Manual { .. }));
assert_eq!(merged.sources.len(), 2);
assert!(merged.source(ProxyConfigSource::Registry).is_some());

Trait Implementations

impl Clone for ProxyConfig

fn clone(&self) -> ProxyConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProxyConfig

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

Formats the value using the given formatter.

impl Default for ProxyConfig

fn default() -> Self

Returns the “default value” for a type.

impl Eq for ProxyConfig

impl PartialEq for ProxyConfig

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

Equality operator ==.

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

Inequality operator !=.