Struct ReloadingConfig 

pub struct ReloadingConfig<T, F> { /* private fields */ }

Available on crate feature reloading only.

An instance of config that may reload itself.

This struct wraps a configuration value and allows it to be atomically swapped with a newly-loaded version. Cloning this object is cheap as it only clones the underlying Arc pointers.

Type Parameters

• T - The configuration type that implements ReloadableConfig
• F - The type of the callback invoked after successful reloads (defaults to ()), see ReloadCallback

Implementations

impl<T> ReloadingConfig<T, ()>

where T: ReloadableConfig,

pub fn build() -> Result<Self, <T as ReloadableConfig>::Error>

Creates a new ReloadingConfig by building the initial configuration.

Errors

Returns an error if the initial configuration build fails.

impl<T, F> ReloadingConfig<T, F>

pub fn with_on_update<U>(self, new: U) -> ReloadingConfig<T, U>

Replaces the update callback with a new one.

See ReloadCallback.

Examples

let config = ReloadingConfig::<MyConfig, _>::build().unwrap()
    .with_on_update(|| println!("Config reloaded!"));

pub fn load(&self) -> Arc<T>

Loads the current configuration.

Returns an Arc to the current configuration value. This is a cheap operation that doesn’t block writers.

impl<T, F> ReloadingConfig<T, F>

where T: ReloadableConfig, F: ReloadCallback,

pub fn reload(&self) -> Result<(), <T as ReloadableConfig>::Error>

Attempts to reload the configuration.

On success, calls the stored update function (if any). On error, leaves the configuration unchanged.

Errors

Returns an error if building the new configuration fails. In this case, the current configuration remains unchanged and the update callback is not invoked.

impl<T, F> ReloadingConfig<T, F>

where T: ReloadableConfig + Send + Sync + 'static, F: ReloadCallback + Clone + Send + Sync + 'static,

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

where <T as ReloadableConfig>::Error: Display,

Available on crate feature signal only.

Sets a listener for SIGHUP.

This spawns a thread and listens for a signal using the signal_hook crate, with all of that crate’s caveats. If you’re setting signals already, you may wish to configure this yourself.

When a SIGHUP signal is received, the configuration will be reloaded. If the reload fails and the tracing feature is enabled, an error will be logged.

Errors

Returns an error if signal registration fails.

Examples

let config = ReloadingConfig::<MyConfig, _>::build().unwrap();

// Set up signal handler
let handle = config.spawn_signal_handler().unwrap();

// The config will now reload when receiving SIGHUP
// handle.join().unwrap(); // Wait for the signal handler thread

Trait Implementations

impl<T, F> Clone for ReloadingConfig<T, F>

where F: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, F: Debug> Debug for ReloadingConfig<T, F>

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

Formats the value using the given formatter.