Struct Remote 

pub struct Remote { /* private fields */ }

The remote source for one configuration type, and its last document.

Remote::new() is const, so this lives in a static — which is how #[dynamic_config] emits it.

What it records about itself

Every fetch this type performs and every delivery it accepts is counted into a RemoteStatus, on the same terms ConfigCell records a ConfigStatus: recorded where it happens, read by an atomic-cheap status, and never on the read path — load() reads document, which this does not touch. The cost is one Instant::now() per fetch, beside a network round trip.

Implementations

impl Remote

pub const fn new() -> Self

Available on non-loom only.

An empty slot: no source, no document.

pub fn set(&self, source: impl RemoteSource)

Installs a blocking source, replacing any previous one.

The document already fetched, if any, is dropped with it — a new source answering with an old store’s values would be a puzzle nobody needs. A fetch from the previous source that is still in flight is discarded when it lands, for the same reason.

The recorded status is dropped with the document: remote_up for the previous store says nothing about this one, and a stale 1 describing a store nobody is talking to any more is worse than no sample at all.

pub fn set_async(&self, source: impl AsyncRemoteSource)

Available on crate feature async only.

Installs an async source, replacing any previous one.

pub fn refresh(&self) -> Result<(), Error>

Fetches, and keeps what came back.

The network round trip happens with no lock held: a slow store cannot make load() — which reads this state for provenance — wait for it. If the source is replaced while the fetch is in flight, the result is discarded and Ok is returned: the fetch did succeed, and the new source’s own refresh is the one that matters now.

Errors

If no source is installed, if the installed one is async — use refresh_async — or if the fetch fails.

pub async fn refresh_async(&self) -> Result<(), Error>

Available on crate feature async only.

Fetches from an async source, and keeps what came back.

A blocking source is not refused — swapping one implementation for the other must not be a breaking change for the caller — but it is not run on the executor either: it goes through off_thread, so an async caller’s worker thread never sits inside a blocking network call.

The same replaced-mid-fetch rule as refresh applies, and matters more here: the unlocked window spans an await.

Errors

If no source is installed, or the fetch fails.

pub fn document(&self) -> Option<Fetched>

The document last fetched, if any.

pub fn is_configured(&self) -> bool

Whether a source is installed.

pub fn status(&self) -> RemoteStatus

How the fetches from this source have gone.

One lock and a clone, no I/O and no network: an exporter may call it per scrape, which is the same contract ConfigCell::status makes.

pub fn describe(&self) -> Option<String>

How the installed source names itself.

pub fn clear(&self)

Drops the document, so the next load sees no remote layer.

A fetch that was already in flight is discarded when it lands, the same way set discards one: clearing is a state change like any other, and a document a caller explicitly dropped must not come back from a round trip that started before they dropped it.

The source is left alone, and so is every RemoteSink taken from it: a watch loop delivering from the same store keeps delivering, and its next push installs normally. Dropping the document is not replacing the store, and only replacing the store ends a watch.

Trait Implementations

impl Debug for Remote

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

Formats the value using the given formatter.

impl Default for Remote

fn default() -> Remote

Returns the “default value” for a type.