Struct ConfigBuilder 

pub struct ConfigBuilder { /* private fields */ }

Implementations

impl ConfigBuilder

pub fn max_message_size(self, size: usize) -> Self

Set the maximum NETCONF message size. None means unlimited.

pub fn connect_timeout(self, timeout: Duration) -> Self

Set the timeout for the TCP/SSH connect phase.

When set, Session::connect_with_config will fail with TransportError::Timeout if the SSH connection is not established within this duration.

Examples found in repository

examples/disconnect_watcher.rs (line 12)

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 hello_timeout(self, timeout: Duration) -> Self

Set the timeout for the NETCONF hello exchange.

Some vendors (e.g. Nokia SR OS) can silently stall during the hello exchange — for example, if the client hello contains an invalid namespace, the server waits indefinitely for a valid hello without returning an error. Without a timeout, the connection hangs forever.

When set, the hello exchange will fail with TransportError::Timeout if the server does not complete the hello within this duration.

pub fn rpc_timeout(self, timeout: Duration) -> Self

Set the timeout for individual RPC operations (send + wait for reply).

When set, RpcFuture::response() will fail with TransportError::Timeout if the server does not reply within this duration.

Examples found in repository

examples/disconnect_watcher.rs (line 11)

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 inactivity_timeout(self, timeout: Duration) -> Self

Set the SSH inactivity timeout (garbage-collect idle connections).

pub fn keepalive_interval(self, interval: Duration) -> Self

Set the SSH keepalive interval (detect dead peers).

Examples found in repository

examples/disconnect_watcher.rs (line 9)

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 keepalive_max(self, max: usize) -> Self

Set the maximum number of missed keepalives before disconnect.

Examples found in repository

examples/disconnect_watcher.rs (line 10)

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 nodelay(self, nodelay: bool) -> Self

Enable or disable TCP_NODELAY on the SSH socket.

Examples found in repository

examples/disconnect_watcher.rs (line 13)

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 window_size(self, size: u32) -> Self

Set the SSH flow-control window size.

Controls how much data the remote side can send before waiting for a window adjustment. Larger values improve throughput for big NETCONF responses at the cost of higher memory usage.

Default: DEFAULT_WINDOW_SIZE (2 MB).

pub fn maximum_packet_size(self, size: u32) -> Self

Set the maximum SSH packet size.

Each SSH data packet is at most this many bytes. Larger values reduce per-packet overhead but increase the minimum buffer allocation.

Default: DEFAULT_MAXIMUM_PACKET_SIZE (32 KB).

pub fn stream_buffer_capacity(self, capacity: usize) -> Self

Set the capacity of the internal channel used by Session::rpc_stream().

This controls how many chunks the background reader can buffer before applying backpressure. Higher values smooth out bursty reads at the cost of memory.

Default: DEFAULT_STREAM_BUFFER_CAPACITY (32).

Panics

Panics if capacity is 0.

pub fn lenient_chunked_framing(self, mode: LenientChunkedFraming) -> Self

Enable lenient chunked framing recovery.

When set to a value other than LenientChunkedFraming::Off, the decoder tolerates incorrect chunk sizes from routers that mis-report the byte count in RFC 6242 chunk headers.

pub fn host_key_verification(self, mode: HostKeyVerification) -> Self

Set the host key verification mode.

pub fn known_hosts_path(self, path: impl Into<PathBuf>) -> Self

Set a custom path to the known_hosts file.

pub fn danger_disable_host_key_verification(self) -> Self

Disable host key verification entirely (insecure — use only for testing).

pub fn jumphost( self, host: impl Into<String>, port: u16, username: impl Into<String>, password: impl Into<String>, ) -> Self

Route the connection through an SSH jumphost (bastion host).

The library will first SSH into the jumphost, open a direct-tcpip channel to the target device, then establish the NETCONF SSH session over that tunnel. The jumphost inherits all SSH settings (host key verification, known_hosts, keepalive, etc.) from this config.

pub fn build(self) -> Config

Examples found in repository

examples/disconnect_watcher.rs (line 14)

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(())
}

Trait Implementations

impl Clone for ConfigBuilder

fn clone(&self) -> ConfigBuilder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConfigBuilder

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

Formats the value using the given formatter.