Struct ConnectionKey 

pub struct ConnectionKey {
    pub hostname: String,
    pub plugin_name: String,
}

A unique identifier for a connection in the connection manager.

ConnectionKey serves as a composite key for looking up and managing connections in the ConnectionManager. It combines a hostname with a connection plugin name to uniquely identify a specific connection instance. This allows the same host to have multiple concurrent connections handled by different plugins (e.g., SSH, NETCONF, HTTP).

The struct implements Hash and Eq to enable its use as a key in hash-based collections like HashMap and DashMap.

Hash Function Behavior

When inserting a ConnectionKey into a hash-based collection (like DashMap in ConnectionManager), the hash function is used to:

1. Compute Hash Value: Both hostname and plugin_name fields are hashed together to produce a single hash value. This is done automatically by Rust’s derive macro for Hash, which hashes each field in declaration order.

2. Determine Bucket: The hash value is used to determine which internal bucket in the hash map should store this key-value pair. This enables O(1) average-case lookup performance.

3. Handle Collisions: If two different keys produce the same hash value (a hash collision), the Eq implementation is used to distinguish between them. The collection stores multiple entries in the same bucket and uses Eq to find the exact match.

4. Enable Deduplication: When inserting with the same hostname and plugin_name, the hash function ensures the key maps to the same bucket, and Eq confirms it’s the same key, allowing the collection to update the existing entry rather than creating a duplicate.

Fields

• hostname - The hostname or IP address of the target device. This identifies the remote endpoint for the connection.
• plugin_name - The connection plugin name (e.g., “ssh”, “netconf”, “http”). This distinguishes between different connection plugin types to the same host.

Examples

Basic Usage

let key = ConnectionKey::new("10.0.0.1", "ssh");
assert_eq!(key.hostname, "10.0.0.1");
assert_eq!(key.plugin_name, "ssh");

Multiple Connection Plugins per Host

use std::collections::HashMap;

let mut connections = HashMap::new();
let ssh_key = ConnectionKey::new("router1", "ssh");
let netconf_key = ConnectionKey::new("router1", "netconf");

// Same host can have different connection plugins
// Each key produces a different hash due to different plugin_name
connections.insert(ssh_key, "SSH connection");
connections.insert(netconf_key, "NETCONF connection");
assert_eq!(connections.len(), 2);

Key Equality and Deduplication

use std::collections::HashMap;

let mut connections = HashMap::new();
let key1 = ConnectionKey::new("router1", "ssh");
let key2 = ConnectionKey::new("router1", "ssh");

// Both keys have the same hostname and plugin_name
// They produce the same hash and are equal via Eq
connections.insert(key1, "First connection");
connections.insert(key2, "Second connection"); // Replaces first
assert_eq!(connections.len(), 1);
assert_eq!(connections.values().next(), Some(&"Second connection"));

Hash-Based Lookup in ConnectionManager

let manager = ConnectionManager::default();
let key = ConnectionKey::new("router1", "ssh");

// The hash function enables fast lookup:
// 1. Hash is computed from key
// 2. Hash determines which bucket to search
// 3. Eq is used to find exact match in bucket
if let Some(connection) = manager.get(&key) {
    println!("Found existing connection");
}

Fields

hostname: String

plugin_name: String

Implementations

impl ConnectionKey

pub fn new(hostname: impl Into<String>, plugin_name: impl Into<String>) -> Self

Creates a new ConnectionKey from a hostname and plugin name.

This constructor provides a convenient way to create a connection key by accepting any type that can be converted into a String for both the hostname and connection type parameters. This allows passing &str, String, or other string-like types without explicit conversion.

The resulting key uniquely identifies a connection in the ConnectionManager by combining the target hostname with the connection plugin name.

Parameters

• hostname - The hostname or IP address of the target device. Accepts any type implementing Into<String>, such as &str or String. This identifies the remote endpoint for the connection.
• plugin_name - The connection plugin name (e.g., “ssh”, “netconf”, “http”). Accepts any type implementing Into<String>. This distinguishes between different connection plugin names to the same host.

Returns

Returns a new ConnectionKey instance with the provided hostname and plugin name.

Examples

// Using string slices
let key1 = ConnectionKey::new("10.0.0.1", "ssh");

// Using owned strings
let hostname = String::from("router1");
let plugin_name = String::from("netconf");
let key2 = ConnectionKey::new(hostname, plugin_name);

// Mixed types
let key3 = ConnectionKey::new("10.0.0.2", String::from("http"));

Trait Implementations

impl Clone for ConnectionKey

fn clone(&self) -> ConnectionKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConnectionKey

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

Formats the value using the given formatter.

impl Eq for ConnectionKey

impl Hash for ConnectionKey

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ConnectionKey

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ConnectionKey