Struct Config 

pub struct Config { /* private fields */ }

Configuration for a NETCONF session.

Use Config::builder() for a fluent API, or Config::default() for sensible defaults.

Example

use std::time::Duration;
use netconf_rust::Config;

let config = Config::builder()
    .hello_timeout(Duration::from_secs(10))
    .connect_timeout(Duration::from_secs(5))
    .nodelay(true)
    .build();

Implementations

impl Config

pub fn builder() -> ConfigBuilder

Examples found in repository

examples/disconnect_watcher.rs (line 8)

async fn main() -> netconf_rust::Result<()> {
    let config = Config::builder()
        .keepalive_interval(Duration::from_secs(10))
        .keepalive_max(3)
        .rpc_timeout(Duration::from_secs(30))
        .connect_timeout(Duration::from_secs(10))
        .nodelay(true)
        .build();

    let session = Arc::new(
        Session::connect_with_config("localhost", 830, "netconf", "netconf", config).await?,
    );

    println!("Connected (session {})", session.session_id());

    // Spawn a background task that fires when the session disconnects.
    // This is the pattern you'd use in a long-running service to clean up
    // sessions from a DashMap or similar structure.
    let watcher_session = Arc::clone(&session);
    let watcher = tokio::spawn(async move {
        let reason = watcher_session.disconnected().await;
        println!("Disconnect detected: {reason}");
        // In a real service you'd remove the session from your map here:
        //   sessions.remove(&uuid);
    });

    // Normal operations — the watcher runs in the background
    let config = session
        .get_config(netconf_rust::Datastore::Running, None)
        .await?;
    println!("Got config ({} bytes)", config.len());

    // You can also race an RPC against disconnect using select!
    tokio::select! {
        result = session.get_config(netconf_rust::Datastore::Running, None) => {
            match result {
                Ok(data) => println!("Got config again ({} bytes)", data.len()),
                Err(e) => eprintln!("RPC failed: {e}"),
            }
        }
        reason = session.disconnected() => {
            eprintln!("Connection lost while waiting for RPC: {reason}");
        }
    }

    // Graceful close — the watcher will fire with DisconnectReason::Eof
    // after the server acknowledges the close and drops the connection.
    session.close_session().await?;
    println!("Session closed");

    // Wait for the watcher to complete
    let _ = watcher.await;

    Ok(())
}

pub fn max_message_size(&self) -> Option<usize>

Maximum message size limit, or None for unlimited.

pub fn connect_timeout(&self) -> Option<Duration>

Timeout for the TCP/SSH connect phase.

pub fn hello_timeout(&self) -> Option<Duration>

Timeout for the NETCONF hello exchange.

pub fn rpc_timeout(&self) -> Option<Duration>

Timeout for individual RPC operations.

pub fn window_size(&self) -> u32

SSH flow-control window size.

Returns the configured value, or DEFAULT_WINDOW_SIZE if not set.

pub fn maximum_packet_size(&self) -> u32

Maximum SSH packet size.

Returns the configured value, or DEFAULT_MAXIMUM_PACKET_SIZE if not set.

pub fn stream_buffer_capacity(&self) -> usize

Capacity of the internal channel used by streaming RPCs.

pub fn lenient_chunked_framing(&self) -> LenientChunkedFraming

Lenient chunked framing recovery mode.

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Config

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

Formats the value using the given formatter.

impl Default for Config

fn default() -> Self

Returns the “default value” for a type.