Yggdrasilctl

https://docs.rs/yggdrasilctl
Admin
A library for accessing Admin API of Yggdrasil Network router, supporting both sync and async...
Tokens:42,750
Snippets:353
Trust Score:9.1
Update:3 months ago
Show doc for...
Tokens:
Raw
### Example Searches

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.ListEntry.html?search=

Demonstrates example search queries, useful for understanding search patterns.

```text
  * std::vec
  * u32 -> bool
  * Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Get Multicast Interfaces

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Retrieves a list of network interfaces configured for multicast.

```APIDOC
## get_multicast_interfaces

### Description
Retrieves a list of network interfaces that are configured to support multicast operations within the Yggdrasil network.

### Method
```
pub async fn get_multicast_interfaces(&mut self) -> RequestResult<Vec<String>>
```

### Returns
- `RequestResult<Vec<String>>`: A result containing a vector of strings, where each string is the name of a multicast-enabled interface, or an error.
```

--------------------------------

### Endpoint Implementation: Network Information Methods

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for retrieving various network-related information. These include getting peers, sessions, self-entry details, paths, DHT entries, multicast interfaces, tun information, and tree structures.

```rust
pub fn get_peers(&mut self) -> RequestResult<Vec<PeerEntry>>
```

```rust
pub fn get_sessions(&mut self) -> RequestResult<Vec<SessionEntry>>
```

```rust
pub fn get_self(&mut self) -> RequestResult<SelfEntry>
```

```rust
pub fn get_paths(&mut self) -> RequestResult<Vec<PathEntry>>
```

```rust
pub fn get_dht(&mut self) -> RequestResult<Vec<DHTEntry>>
```

```rust
pub fn get_multicast_interfaces(&mut self) -> RequestResult<Vec<String>>
```

```rust
pub fn get_tun(&mut self) -> RequestResult<TunEntry>
```

```rust
pub fn get_tree(&mut self) -> RequestResult<Vec<TreeEntry>>
```

--------------------------------

### Endpoint Get Node Info Method

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html?search=std%3A%3Avec

Retrieves detailed node information for a given key from the Yggdrasil node.

```rust
pub fn get_node_info(
    &mut self,
    key: String,
) -> RequestResult<HashMap<String, Value>>
```

--------------------------------

### Get Paths

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html

Retrieves information about the network paths. This method requires a mutable reference to the Endpoint.

```rust
pub fn get_paths(&mut self) -> RequestResult<Vec<PathEntry>>
```

--------------------------------

### Test yggdrasilctl Compatibility

Source: https://docs.rs/yggdrasilctl/latest/index.html

Run tests to verify compatibility with your installed yggdrasil-go version by setting the YGGDRASIL_SOCKET environment variable.

```bash
$ YGGDRASIL_SOCKET="/run/yggdrasil/yggdrasil.sock" cargo test -p yggdrasilctl
```

--------------------------------

### Get Multicast Interfaces

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Retrieves a list of multicast interfaces configured on the network. The response is directly mapped to a Vec of Strings.

```rust
#[derive(Debug, Deserialize)]
#[cfg_attr(test, serde(deny_unknown_fields))]
struct MulticastInterfaces {
    multicast_interfaces: Vec<String>,
}
self.request::<MulticastInterfaces>("getmulticastinterfaces")
    .await
    .map(|e| e.map(|e| e.multicast_interfaces))
```

--------------------------------

### Get Node Info

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Fetches detailed information for a specific node identified by its key. Requires the node's key as a String argument.

```rust
let args = hash_map! {
    ("key".into()): key.into()
};
self.request_args("getnodeinfo", args).await
```

--------------------------------

### Get Paths Information (v0.4.5+)

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Retrieves network path information for router versions v0.4.5 and above. Uses a specific struct for parsing.

```rust
#[derive(Debug, Deserialize)]
#[cfg_attr(test, serde(deny_unknown_fields))]
struct Paths {

```

--------------------------------

### Get Paths Information (v0.4.4)

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Retrieves network path information for router version v0.4.4. Parses a nested HashMap structure.

```rust
#[derive(Debug, Deserialize)]
#[cfg_attr(test, serde(deny_unknown_fields))]
struct Entry {
    key: String,
    path: Vec<u64>,
}
#[derive(Debug, Deserialize)]
#[cfg_attr(test, serde(deny_unknown_fields))]
struct Paths {
    paths: HashMap<Ipv6Addr, Entry>,
}
match self.request::<Paths>("getpaths").await? {
    Ok(paths) => {
        let vec = paths
            .paths
            .into_iter()
            .map(|(k, v)| PathEntry {
                address: k,
                key: v.key,
                path: v.path,
                sequence: None,
            })
            .collect();
        Ok(Ok(vec))
    }
    Err(err) => Ok(Err(err)),
}
```

--------------------------------

### List Commands (v0.4.5+)

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Lists available commands and their associated details for router versions v0.4.5 and later. This implementation directly maps the response to a Vec of ListEntry.

```rust
#[derive(Debug, Deserialize)]
#[cfg_attr(test, serde(deny_unknown_fields))]
struct List {
    list: Vec<ListEntry>,
}
self.request::<List>("list")
    .await
    .map(|e| e.map(|e| e.list))
```

--------------------------------

### Get Self

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Retrieves information about the current Yggdrasil node.

```APIDOC
## Get Self

### Description
Retrieves information about the current Yggdrasil node, including its build details, key, and network address.

### Method
GET (inferred from `request`)

### Endpoint
`/getself` (inferred from `request`)

### Parameters
None

### Response
#### Success Response (200)
- **address** (Ipv6Addr) - The IPv6 address of the node.
- **key** (String) - The public key of the node.
- **build_name** (String) - The name of the Yggdrasil build.
- **build_version** (String) - The version of the Yggdrasil build.
- **subnet** (String) - The subnet the node belongs to.
- **routing_entries** (Option<Vec<PathEntry>>) - Routing entries for the node (may be None).
```

--------------------------------

### Get Paths

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Retrieves the routing paths known to the Yggdrasil node.

```APIDOC
## Get Paths

### Description
Retrieves the routing paths known to the Yggdrasil node. This includes the destination address, the key associated with the path, and the path itself.

### Method
GET (inferred from `request`)

### Endpoint
`/getpaths` (inferred from `request`)

### Parameters
None

### Response
#### Success Response (200)
- **paths** (Array<PathEntry>) - An array of PathEntry objects, where each object contains:
  - **address** (Ipv6Addr) - The destination IPv6 address.
  - **key** (String) - The key associated with the path.
  - **path** (Array<u64>) - The sequence of nodes forming the path.
  - **sequence** (Option<u64>) - The sequence number of the path (may be None).
```

--------------------------------

### Endpoint Initialization

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=

Provides methods to create an Endpoint instance, either by automatically detecting the router version or by explicitly specifying it.

```APIDOC
## attach

### Description
Initializes an Endpoint by attempting to automatically detect the router version.

### Method
`async fn attach(socket: S) -> Self`

### Parameters
- `socket` (S): The underlying communication socket (must implement `AsyncRead + AsyncWrite + Unpin`).

### Response Example
```json
{
  "example": "Endpoint instance"
}
```

## attach_version

### Description
Initializes an Endpoint with a pre-determined router version.

### Method
`fn attach_version(socket: S, router_version: RouterVersion) -> Self`

### Parameters
- `socket` (S): The underlying communication socket.
- `router_version` (RouterVersion): The specific version of the router.

### Response Example
```json
{
  "example": "Endpoint instance"
}
```
```

--------------------------------

### Live Test Request with Standard Library

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=u32+-%3E+bool

Executes a request against a Unix domain socket using standard library networking. Requires the `use_std` feature to be enabled.

```rust
use super::*;
use std::os::unix::net::UnixStream;

#[test]
fn test_request() {
    let e = UnixStream::connect(SOCKET_PATH).unwrap();
    request(e);
}
```

--------------------------------

### Implement CloneToUninit for T

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/enum.RouterVersion.html?search=u32+-%3E+bool

Nightly-only experimental API for copying data to uninitialized memory.

```rust
unsafe impl<T> CloneToUninit for T where T: Clone {
    unsafe fn clone_to_uninit(&self, dest: *mut u8) {
        // ... implementation details ...
    }
}
```

--------------------------------

### Get Node Info

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Retrieves information about a specific node identified by its key.

```APIDOC
## get_node_info

### Description
Fetches detailed information for a given node identified by its public key.

### Method
```
pub async fn get_node_info(&mut self, key: String) -> RequestResult<HashMap<String, Value>>
```

### Parameters
#### Path Parameters
- **key** (String) - Required - The public key of the node to retrieve information for.

### Returns
- `RequestResult<HashMap<String, Value>>`: A result containing a HashMap where keys are information fields and values are their corresponding data, or an error.
```

--------------------------------

### Any Trait Implementation for T

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.ListEntry.html

Gets the TypeId of a type T, allowing for runtime type identification.

```rust
fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`. Read more
```

--------------------------------

### Test Case: Simple Endpoint Request

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates a basic test case using the `mock_reader` macro to simulate a successful endpoint request and deserialize the response. It defines a specific struct for the expected response.

```rust
    #[test]
    fn simple() {
        let sock = mock_reader!(
            1 => &{
                let json = serde_json::json!({
                    "status": "success",
                    "request": {
                        "request": "test",
                        "arguments": {},
                    },
                    "response": {
                        "mock": 42,
                    }
                });
                let mut vec = serde_json::to_vec_pretty(&json).unwrap();
                vec.push(b'\n');
                vec
            }
        );
        let mut e = Endpoint::attach_version(sock, RouterVersion::v0_5_0__);
        #[derive(Debug, Deserialize, PartialEq, Eq)]
        struct MockResult {
            mock: u32,
        }
        let res: MockResult = Endpoint::request(&mut e, "test").unwrap().unwrap();
```

--------------------------------

### Get Router Version

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=std%3A%3Avec

Returns the current router version associated with the endpoint.

```rust
pub fn get_version(&self) -> RouterVersion {
    self.router_version.clone()
}

```

--------------------------------

### Endpoint Creation

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html?search=std%3A%3Avec

Methods for creating and initializing an Endpoint instance.

```APIDOC
## Endpoint Creation

### `attach(socket: S) -> Self`

Creates a new Endpoint instance by attaching to a given socket.

### `attach_version(socket: S, router_version: RouterVersion) -> Self`

Creates a new Endpoint instance by attaching to a given socket with a specified router version.
```

--------------------------------

### Get Tree Structure

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Retrieves the tree structure representing the Yggdrasil network topology.

```APIDOC
## get_tree

### Description
Retrieves a representation of the Yggdrasil network's tree structure, which outlines the hierarchical organization of nodes.

### Method
```
pub async fn get_tree(&mut self) -> RequestResult<Vec<TreeEntry>>
```

### Returns
- `RequestResult<Vec<TreeEntry>>`: A result containing a vector of `TreeEntry` objects representing the network's tree structure, or an error.
```

--------------------------------

### Endpoint Request Method

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=u32+-%3E+bool

Demonstrates how to make a request using the `Endpoint::request` method and handle the deserialized response.

```APIDOC
## Endpoint Request

### `Endpoint::request` Method

This method is used to send a request and receive a deserialized response. The example shows a test case where a mock reader is used to simulate a response.

```rust
let res: MockResult = Endpoint::request(&mut e, "test").unwrap().unwrap();
```

**Example Usage:**

```rust
#[derive(Debug, Deserialize, PartialEq, Eq)]
struct MockResult {
    mock: u32,
}

// Assuming 'e' is an initialized Endpoint instance
let res: MockResult = Endpoint::request(&mut e, "test").unwrap().unwrap();

assert_eq!(res.mock, 42);
```
```

--------------------------------

### Live Test Request with Tokio

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=u32+-%3E+bool

Executes a request against a Unix domain socket using Tokio for asynchronous operations. Requires the `use_tokio` feature to be enabled.

```rust
use super::*;
use tokio::net::UnixStream;

#[tokio::test]
async fn test_request() {
    let e = UnixStream::connect(SOCKET_PATH).await.unwrap();
    request(e).await;
}
```

--------------------------------

### Get TUN Information

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Retrieves information about the TUN (network tunnel) interface used by Yggdrasil.

```APIDOC
## get_tun

### Description
Retrieves details about the TUN (network tunnel) interface that Yggdrasil utilizes for its network operations.

### Method
```
pub async fn get_tun(&mut self) -> RequestResult<TunEntry>
```

### Returns
- `RequestResult<TunEntry>`: A result containing `TunEntry` object with details about the TUN interface, or an error.
```

--------------------------------

### Get Tree Structure

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Retrieves the network tree structure. The response is mapped to a Vec of TreeEntry.

```rust
#[derive(Debug, Deserialize)]
#[cfg_attr(test, serde(deny_unknown_fields))]
struct Tree {
    tree: Vec<TreeEntry>,
}
self.request::<Tree>("gettree")
    .await
    .map(|t| t.map(|r| r.tree))
```

--------------------------------

### List Commands

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Lists available commands and their associated fields. The output format varies slightly based on the router version.

```APIDOC
## list

### Description
Retrieves a list of available commands within the Yggdrasil control interface, along with their descriptions and expected fields. The structure of the returned list is version-dependent.

### Method
```
pub async fn list(&mut self) -> RequestResult<Vec<ListEntry>>
```

### Returns
- `RequestResult<Vec<ListEntry>>`: A result containing a vector of `ListEntry` objects, where each entry details a command, its description, and associated fields. Returns an error if the operation fails.
```

--------------------------------

### Get Sessions

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Retrieves a list of active sessions. The format of session data differs between router versions.

```APIDOC
## get_sessions

### Description
Retrieves a list of active sessions. The format of session data differs between router versions.

### Method
`get_sessions()`

### Parameters
None

### Response
- `RequestResult<Vec<SessionEntry>>`: A result containing either an error or a vector of `SessionEntry` objects.

### Response Example (pre-v0.4.4)
```json
{
  "sessions": {
    "2001:db8::1": {
      "key": "session_key_1"
    }
  }
}
```

### Response Example (v0.4.4 and later)
```json
{
  "sessions": [
    {
      "address": "2001:db8::1",
      "key": "session_key_1",
      "bytes_recvd": 1000,
      "bytes_sent": 2000,
      "uptime": 3600.0
    }
  ]
}
```
```

--------------------------------

### Endpoint Implementation: Node Information and Listing

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for retrieving node-specific information. `get_node_info` fetches detailed information for a given key, and `list` retrieves a list of entries.

```rust
pub fn get_node_info( &mut self, key: String, ) -> RequestResult<HashMap<String, Value>>
```

```rust
pub fn list(&mut self) -> RequestResult<Vec<ListEntry>>
```

--------------------------------

### Mock Reader Implementation for Tests

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=

A macro to create a mock reader for testing purposes. It simulates read operations by returning predefined byte slices based on a read counter.

```Rust
macro_rules! mock_reader {
    ($($read_count:expr => $slice:expr $(,)?)*) => {{
        struct MockReader {
            read_counter: u32,
        }
        impl Write for MockReader {
            fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
                Ok(buf.len())
            }
            fn flush(&mut self) -> io::Result<()> {
                Ok(())
            }
        }
        impl Read for MockReader {
            fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
                self.read_counter += 1;
                match self.read_counter {
                    $($read_count => {
                        return Cursor::new(buf).write($slice);
                    }),*
                    _ => unreachable!(),
                }
            }
        }
        impl Drop for MockReader {
            fn drop(&mut self) {
                let read_expected = 0 $(.max($read_count))*;
                if self.read_counter != read_expected {
                    panic!("Mocked socket seen {} reads, while expected {}", self.read_counter, read_expected)
                }
            }
        }
        MockReader { read_counter: 0 }
    }};
    }
```

--------------------------------

### Get Self Entry

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html

Retrieves information about the local node. This method requires a mutable reference to the Endpoint.

```rust
pub fn get_self(&mut self) -> RequestResult<SelfEntry>
```

--------------------------------

### Get Router Version

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html

Retrieves the `RouterVersion` associated with the Endpoint. This method takes an immutable reference to self.

```rust
pub fn get_version(&self) -> RouterVersion
```

--------------------------------

### Live Request with futures::io::AllowStdIo

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Executes a request using the futures library's asynchronous I/O wrappers. This test case is for environments with the `use_futures` feature enabled.

```rust
use super::*;
use futures::io::AllowStdIo;
use futures::executor::block_on;
const SOCKET_PATH: &str = env!("YGGDRASIL_SOCKET");

#[cfg(feature = "use_futures")]
#[test]
fn test_request() {
    let e = AllowStdIo::new(
        std::os::unix::net::UnixStream::connect(SOCKET_PATH).unwrap(),
    );
    block_on(request(e));
}
```

--------------------------------

### Endpoint Construction and Accessors

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html

This section covers methods for constructing an `Endpoint` instance and accessing its underlying socket. These are essential for initializing and managing the connection to the Yggdrasil router.

```APIDOC
## Endpoint Construction and Accessors

### Description
Methods for creating an `Endpoint` instance and accessing its internal state, including the underlying socket and router version.

### Methods

- **`attach(socket: S)`**: Creates a new `Endpoint` instance with the provided socket.
- **`attach_version(socket: S, router_version: RouterVersion)`**: Creates a new `Endpoint` instance with a specified router version.
- **`get_version()`**: Returns the router version associated with this endpoint.
- **`into_inner()`**: Consumes the `Endpoint` and returns the underlying socket.
- **`get_ref()`**: Returns an immutable reference to the underlying socket.
- **`get_mut()`**: Returns a mutable reference to the underlying socket.
```

--------------------------------

### Get Mutable Socket Reference

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=std%3A%3Avec

Provides a mutable reference to the underlying socket, allowing for modifications to the transport layer.

```rust
pub fn get_mut(&mut self) -> &mut S {
    &mut self.socket
}

```

--------------------------------

### List Commands (v0.4.4)

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Lists available commands and their associated fields for router version v0.4.4. This implementation parses a HashMap of command names to entry details.

```rust
#[derive(Debug, Deserialize)]
#[cfg_attr(test, serde(deny_unknown_fields))]
struct Entry {
    fields: Vec<String>,
}
#[derive(Debug, Deserialize)]
#[cfg_attr(test, serde(deny_unknown_fields))]
struct List {
    list: HashMap<String, Entry>,
}
return match self.request::<List>("list").await? {
    Ok(list) => {
        let vec = list
            .list
            .into_iter()
            .map(|(k, v)| ListEntry {
                command: k,
                description: String::new(),
                fields: Some(v.fields),
            })
            .collect();
        Ok(Ok(vec))
    }
    Err(err) => Ok(Err(err)),
};
```

--------------------------------

### Live Test Request with Futures

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=u32+-%3E+bool

Executes a request against a Unix domain socket using the `futures` crate for asynchronous operations. Requires the `use_futures` feature to be enabled.

```rust
use super::*;
use futures::io::AllowStdIo;
use futures::executor::block_on;

#[test]
fn test_request() {
    let e = AllowStdIo::new(
        std::os::unix::net::UnixStream::connect(SOCKET_PATH).unwrap(),
    );
    block_on(request(e));
}
```

--------------------------------

### Get Tree Entries

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html

Retrieves tree-like network structure entries. This method requires a mutable reference to the Endpoint.

```rust
pub fn get_tree(&mut self) -> RequestResult<Vec<TreeEntry>>
```

--------------------------------

### Get Multicast Interfaces

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html

Retrieves a list of available multicast interfaces. This method requires a mutable reference to the Endpoint.

```rust
pub fn get_multicast_interfaces(&mut self) -> RequestResult<Vec<String>>
```

--------------------------------

### Endpoint Construction and Utility Methods

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html?search=u32+-%3E+bool

Methods for constructing an Endpoint instance and accessing its underlying socket.

```APIDOC
## Endpoint Construction and Utility Methods

### Description
Methods for constructing an Endpoint instance and accessing its underlying socket.

### Methods

#### `attach(socket: S) -> Self`
- **Description**: Creates a new Endpoint instance by attaching it to a given socket.
- **Parameters**:
  - `socket` (S): The asynchronous write and read socket to attach.
- **Returns**: `Self` (an Endpoint instance)

#### `attach_version(socket: S, router_version: RouterVersion) -> Self`
- **Description**: Creates a new Endpoint instance with a specified router version, attached to a given socket.
- **Parameters**:
  - `socket` (S): The asynchronous write and read socket to attach.
  - `router_version` (RouterVersion): The version of the router.
- **Returns**: `Self` (an Endpoint instance)

#### `get_version(&self) -> RouterVersion`
- **Description**: Returns the router version associated with this Endpoint.
- **Returns**: `RouterVersion`

#### `into_inner(self) -> S`
- **Description**: Consumes the Endpoint and returns the underlying socket.
- **Returns**: `S` (the inner socket)

#### `get_ref(&self) -> &S`
- **Description**: Returns an immutable reference to the underlying socket.
- **Returns**: `&S` (an immutable reference to the socket)

#### `get_mut(&mut self) -> &mut S`
- **Description**: Returns a mutable reference to the underlying socket.
- **Returns**: `&mut S` (a mutable reference to the socket)
```

--------------------------------

### Reading Responses from a Mock Reader

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the `read_response` function with different mock reader configurations to handle various response formats, including multi-line and fragmented responses.

```rust
use super::protocol::read_response;
let mut scratch = Vec::new();
assert_eq!(
    read_response(&mut mock_reader!(1 => b"{ ... }", 2 => b"" ), &mut scratch).unwrap(),
    b"{ ... }"
);
assert_eq!(
    read_response(&mut mock_reader!(1 => b"{ ... }\n"), &mut scratch).unwrap(),
    b"{ ... }\n"
);
assert_eq!(
    read_response(&mut mock_reader!(1 => b"{\n ... \n}\n"), &mut scratch).unwrap(),
    b"{\n ... \n}\n"
);
assert_eq!(
    read_response(
        &mut mock_reader!(
            1 => b"{",
            2 => b" ... ",
            3 => b"}\n",
        ),
        &mut scratch
    )
    .unwrap(),
    b"{ ... }\n"
);
```

```rust
let line: String = std::iter::repeat_n('a', 100).collect();
let lines: String = std::iter::repeat_n(format!("{line}",\n), 1000).collect();
let long = format!("{{\n{lines}\n}}\n");
assert!(long.len() > 8192 << 2);
assert_eq!(
    read_response(&mut Cursor::new(long.as_bytes()), &mut scratch).unwrap(),
    long.as_bytes(),
);
```

--------------------------------

### Get Sessions

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html

Retrieves a list of active sessions on the Yggdrasil network. This method requires a mutable reference to the Endpoint.

```rust
pub fn get_sessions(&mut self) -> RequestResult<Vec<SessionEntry>>
```

--------------------------------

### Endpoint::request_args

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=u32+-%3E+bool

Asynchronously sends a request with arguments to the Yggdrasil router and deserializes the response.

```APIDOC
## Endpoint::request_args

### Description
Sends a request to the Yggdrasil router with specified arguments and asynchronously waits for the response. The response is deserialized into the specified type `T`.

### Method
`async fn request_args<T: for<'a> Deserialize<'a>>(&mut self, request: &str, arguments: HashMap<String, serde_json::Value>) -> RequestResult<T>`

### Parameters
* `request`: The name of the request to send.
* `arguments`: A `HashMap` containing the arguments for the request.

### Returns
A `RequestResult` containing either the deserialized response of type `T` or an `io::Error`.

### Example
```rust
let mut args = HashMap::new();
args.insert("node_id".to_string(), serde_json::json!("some_node_id"));
let node_info: serde_json::Value = endpoint.request_args("getnode", args).await?;
```
```

--------------------------------

### Get Peers

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html

Retrieves a list of connected peers on the Yggdrasil network. This method requires a mutable reference to the Endpoint.

```rust
pub fn get_peers(&mut self) -> RequestResult<Vec<PeerEntry>>
```

--------------------------------

### Get Router Version

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the currently configured router version for the endpoint. This is useful for debugging or conditional logic.

```rust
pub fn get_version(&self) -> RouterVersion {
        self.router_version.clone()
    }
```

--------------------------------

### Implement PartialEq for RouterVersion

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/enum.RouterVersion.html?search=u32+-%3E+bool

Allows comparison of RouterVersion values for equality.

```rust
impl PartialEq for RouterVersion {
    fn eq(&self, other: &RouterVersion) -> bool {
        // ... implementation details ...
    }
    fn ne(&self, other: &Rhs) -> bool {
        // ... implementation details ...
    }
}
```

--------------------------------

### Get TUN Device Info

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Fetches information about the TUN device used for network tunneling. The response is mapped to a TunEntry.

```rust
self.request("gettun").await
```

--------------------------------

### Test Endpoint Request

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html

Demonstrates a basic test case using the mock reader to simulate an endpoint request and deserialize a successful response.

```rust
let sock = mock_reader!(
            1 => &{
                let json = serde_json::json!({
                    "status": "success",
                    "request": {
                        "request": "test",
                        "arguments": {},
                    },
                    "response": {
                        "mock": 42,
                    }
                });
                let mut vec = serde_json::to_vec_pretty(&json).unwrap();
                vec.push(b'\n');
                vec
            }
        );
        let mut e = Endpoint::attach_version(sock, RouterVersion::v0_5_0__);
        #[derive(Debug, Deserialize, PartialEq, Eq)]
        struct MockResult {
            mock: u32,
        }
        let res: MockResult = Endpoint::request(&mut e, "test").unwrap().unwrap();
```

--------------------------------

### Live Request with tokio::net::UnixStream

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Executes an asynchronous request against the Yggdrasil router using Tokio's Unix stream. This is intended for use with the `use_tokio` feature.

```rust
use super::*;
use tokio::net::UnixStream;
const SOCKET_PATH: &str = env!("YGGDRASIL_SOCKET");

#[cfg(feature = "use_tokio")]
#[tokio::test]
async fn test_request() {
    let e = UnixStream::connect(SOCKET_PATH).await.unwrap();
    request(e).await;
}
```

--------------------------------

### Get Self Information (v0.4.5-v0.4.7)

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Retrieves self-information for router versions v0.4.5 to v0.4.7. Parses a direct Entry structure.

```rust
#[derive(Debug, Serialize, Deserialize)]
#[cfg_attr(test, serde(deny_unknown_fields))]
pub struct Entry {
    pub build_name: String,
    pub build_version: String,
    pub key: String,
    pub address: Ipv6Addr,
    #[allow(dead_code)]
    pub coords: Vec<u64>,
    pub subnet: String,
}
match self.request::<Entry>("getself").await? {
    Ok(v) => Ok(Ok(SelfEntry {
        address: v.address,
        key: v.key,
        build_name: v.build_name,
        build_version: v.build_version,
        subnet: v.subnet,
        routing_entries: None,
    })),
    Err(v) => Ok(Err(v)),
}
```

--------------------------------

### Live Test with Tokio UnixStream

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=std%3A%3Avec

Connects to the Yggdrasil daemon using Tokio's UnixStream and performs various requests. This test requires the 'use_tokio' feature to be enabled.

```rust
    #[cfg(feature = "use_tokio")]
    #[tokio::test]
    async fn test_request() {
        let e = tokio::net::UnixStream::connect(SOCKET_PATH).await.unwrap();
        request(e).await;
    }
```

--------------------------------

### Get Socket Reference

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=std%3A%3Avec

Provides an immutable reference to the underlying socket, useful for inspecting its state without taking ownership.

```rust
pub fn get_ref(&self) -> &S {
    &self.socket
}

```

--------------------------------

### Live Test with Standard UnixStream

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=std%3A%3Avec

Connects to the Yggdrasil daemon using the standard library's UnixStream and performs various requests. This test requires the 'use_std' feature to be enabled.

```rust
    #[cfg(feature = "use_std")]
    #[test]
    fn test_request() {
        let e = std::os::unix::net::UnixStream::connect(SOCKET_PATH).unwrap();
        request(e);
    }
```

--------------------------------

### Get Tun Entry

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html

Retrieves the TUN (network tunnel) entry information. This method requires a mutable reference to the Endpoint.

```rust
pub fn get_tun(&mut self) -> RequestResult<TunEntry>
```

--------------------------------

### Implement StructuralPartialEq for RouterVersion

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/enum.RouterVersion.html?search=u32+-%3E+bool

Provides structural equality comparison for RouterVersion.

```rust
impl StructuralPartialEq for RouterVersion {}
```

--------------------------------

### Get DHT Entries

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html

Retrieves Distributed Hash Table (DHT) entries. This method requires a mutable reference to the Endpoint.

```rust
pub fn get_dht(&mut self) -> RequestResult<Vec<DHTEntry>>
```

--------------------------------

### Endpoint Implementation: Request Methods

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for sending requests through the endpoint. `request` sends a raw string request, while `request_args` allows sending requests with additional arguments.

```rust
pub fn request<T: for<'a> Deserialize<'a>>( &mut self, request: &str, ) -> RequestResult<T>
```

```rust
pub fn request_args<T: for<'a> Deserialize<'a>>( &mut self, request: &str, arguments: HashMap<String, Value>, ) -> RequestResult<T>
```

--------------------------------

### Live Test Request with Standard Library

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html

Executes a request to the Yggdrasil socket using standard library Unix streams. Requires the 'use_std' feature.

```rust
use super::*;
const SOCKET_PATH: &str = env!("YGGDRASIL_SOCKET");

#[test]
fn test_request() {
    let e = std::os::unix::net::UnixStream::connect(SOCKET_PATH).unwrap();
    request(e);
}
```

--------------------------------

### Get Mutable Reference to Socket

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides a mutable reference to the underlying socket. Allows modification of the socket's state.

```rust
pub fn get_mut(&mut self) -> &mut S {
        &mut self.socket
    }
```

--------------------------------

### Mock Reader Macro for Tests

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

A macro to create a mock reader for testing purposes. It simulates read operations based on predefined counts and slices, ensuring that the expected number of reads occur. Panics if the read count does not match expectations.

```rust
macro_rules! mock_reader {
        ($($read_count:expr => $slice:expr $(,)?)*) => {{ 
            struct MockReader {
                read_counter: u32,
            }
            impl Write for MockReader {
                fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
                    Ok(buf.len())
                }
                fn flush(&mut self) -> io::Result<()> {
                    Ok(())
                }
            }
            impl Read for MockReader {
                fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
                    self.read_counter += 1;
                    match self.read_counter {
                        $($read_count => {
                            return Cursor::new(buf).write($slice);
                        }),*
                        _ => unreachable!(),
                    }
                }
            }
            impl Drop for MockReader {
                fn drop(&mut self) {
                    let read_expected = 0 $(.max($read_count))*;
                    if self.read_counter != read_expected {
                        panic!("Mocked socket seen {} reads, while expected {}", self.read_counter, read_expected)
                    }
                }
            }
            MockReader { read_counter: 0 }
        }};
    }
```

--------------------------------

### Get Immutable Reference to Socket

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides an immutable reference to the underlying socket. Useful for inspecting the socket without modifying it.

```rust
pub fn get_ref(&self) -> &S {
        &self.socket
    }
```

--------------------------------

### Endpoint::request_args

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Sends a request to the router with specified arguments.

```APIDOC
## Endpoint::request_args

### Description
Sends a request to the Yggdrasil router with the specified name and a `HashMap` of arguments. It deserializes the response into the provided generic type `T`.

### Method
`async fn request_args<T: for<'a> Deserialize<'a>>(&mut self, request: &str, arguments: HashMap<String, serde_json::Value>) -> RequestResult<T>`

### Parameters
* `request`: The name of the request to send.
* `arguments`: A `HashMap` where keys are argument names (String) and values are `serde_json::Value`.

### Returns
A `RequestResult<T>` which is an `io::Result` containing either a successful deserialized response of type `T` or an error string.
```

--------------------------------

### Consume Endpoint to Get Socket

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Consumes the Endpoint and returns the underlying socket. Use this when you no longer need the Endpoint functionality.

```rust
pub fn into_inner(self) -> S {
        self.socket
    }
```

--------------------------------

### Mock Reader Macro for Tests

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=std%3A%3Avec

A macro to create a mock reader for testing purposes. It simulates read operations based on predefined counts and slices of data. Ensures the correct number of reads are performed.

```rust
macro_rules! mock_reader {
    ($($read_count:expr => $slice:expr $(,)?)*) => {{ 
            struct MockReader {
                read_counter: u32,
            }
            impl Write for MockReader {
                fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
                    Ok(buf.len())
                }
                fn flush(&mut self) -> io::Result<()> {
                    Ok(())
                }
            }
            impl Read for MockReader {
                fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
                    self.read_counter += 1;
                    match self.read_counter {
                        $($read_count => {
                            return Cursor::new(buf).write($slice);
                        }),*
                        _ => unreachable!(),
                    }
                }
            }
            impl Drop for MockReader {
                fn drop(&mut self) {
                    let read_expected = 0 $(.max($read_count))*;
                    if self.read_counter != read_expected {
                        panic!("Mocked socket seen {} reads, while expected {}", self.read_counter, read_expected)
                    }
                }
            }
            MockReader { read_counter: 0 }
        }};
    }
```

--------------------------------

### Endpoint::request_args

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html

Sends a request to the router with specified arguments and deserializes the response.

```APIDOC
## request_args

### Description
Sends a request to the router with specified arguments and deserializes the JSON response into the specified type `T`.

### Method
`async fn request_args<T: for<'a> Deserialize<'a>>(&mut self, request: &str, arguments: HashMap<String, serde_json::Value>) -> RequestResult<T>`

### Parameters
- `request` (&str): The name of the request to send.
- `arguments` (HashMap<String, serde_json::Value>): A map of arguments to include with the request.

### Returns
- `RequestResult<T>`: An `io::Result` containing either a successful deserialized response or an error.
```

--------------------------------

### Endpoint Request with Mocked Response

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=

Demonstrates making a request to an endpoint using a mocked reader and deserializing a successful response.

```Rust
let sock = mock_reader!(
    1 => &{
        let json = serde_json::json!({
            "status": "success",
            "request": {
                "request": "test",
                "arguments": {},
            },
            "response": {
                "mock": 42,
            }
        });
        let mut vec = serde_json::to_vec_pretty(&json).unwrap();
        vec.push(b'\n');
        vec
    }
);
let mut e = Endpoint::attach_version(sock, RouterVersion::v0_5_0__);
#[derive(Debug, Deserialize, PartialEq, Eq)]
struct MockResult {
    mock: u32,
}
let res: MockResult = Endpoint::request(&mut e, "test").unwrap().unwrap();
```

--------------------------------

### Get Self Information (v0.5.0+)

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Retrieves self-information for router version v0.5.0 and above. Uses a simpler request without specific parsing.

```rust
self.request("getself").await
```

--------------------------------

### Get Self Information (v0.4.4)

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Retrieves self-information for router version v0.4.4. Parses a specific nested structure for entry details.

```rust
#[derive(Debug, Deserialize)]
#[cfg_attr(test, serde(deny_unknown_fields))]
struct Entry {
    build_name: String,
    build_version: String,
    key: String,
    #[allow(dead_code)]
    coords: Vec<u64>,
    subnet: String,
}
#[derive(Debug, Deserialize)]
#[cfg_attr(test, serde(deny_unknown_fields))]
struct _SelfEntry {
    #[serde(alias = "self")]
    entry: HashMap<Ipv6Addr, Entry>,
}
match self.request::<_SelfEntry>("getself").await? {
    Ok(entry) => match entry.entry.into_iter().next() {
        Some((k, v)) => Ok(Ok(SelfEntry {
            address: k,
            key: v.key,
            build_name: v.build_name,
            build_version: v.build_version,
            subnet: v.subnet,
            routing_entries: None,
        })),
        None => Ok(Err("Unknown".to_string())),
    },
    Err(err) => Ok(Err(err)),
}
```

--------------------------------

### Send Request With Arguments

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Sends a request to the Yggdrasil router with specified arguments. Use this for requests that require parameters.

```rust
pub async fn request_args<T: for<'a> Deserialize<'a>>(
        &mut self,
        request: &str,
        arguments: HashMap<String, serde_json::Value>,
    ) -> RequestResult<T> {
        let request = protocol::Request {
            request,
            arguments,
            keepalive: true,
        };
        self.socket
            .write_all(serde_json::to_vec(&request)?.as_slice())
            .await?;

        let buf = protocol::read_response(&mut self.socket, &mut self.scratch).await?;

        let response: protocol::Response<T> = serde_json::from_slice(buf).map_err(|err| {
            Error::new(
                ErrorKind::InvalidData,
                format!(

```

--------------------------------

### Get Node Info

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html

Retrieves detailed information about a specific node identified by its key. This method requires a mutable reference to the Endpoint.

```rust
pub fn get_node_info( &mut self, key: String, ) -> RequestResult<HashMap<String, Value>>
```

--------------------------------

### Implement Any for T

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/enum.RouterVersion.html?search=u32+-%3E+bool

Provides dynamic type information for any type T.

```rust
impl<T> Any for T where T: 'static + ?Sized {
    fn type_id(&self) -> TypeId {
        // ... implementation details ...
    }
}
```

--------------------------------

### Endpoint Implementation: Peer Management

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.Endpoint.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for managing peers on the network. `add_peer` adds a new peer with an optional interface, while `remove_peer` removes an existing peer.

```rust
pub fn add_peer( &mut self, uri: String, interface: Option<String>, ) -> RequestResult<Empty>
```

```rust
pub fn remove_peer( &mut self, uri: String, interface: Option<String>, ) -> RequestResult<Empty>
```

--------------------------------

### Endpoint Information and Access

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=

Methods for retrieving the router version, accessing the inner socket, and getting mutable or immutable references to the socket.

```APIDOC
## get_version

### Description
Returns the currently detected or specified router version.

### Method
`fn get_version(&self) -> RouterVersion`

### Response Example
```json
{
  "example": "RouterVersion enum value"
}
```

## into_inner

### Description
Consumes the Endpoint and returns the underlying socket.

### Method
`fn into_inner(self) -> S`

### Response Example
```json
{
  "example": "The underlying socket object"
}
```

## get_ref

### Description
Provides an immutable reference to the underlying socket.

### Method
`fn get_ref(&self) -> &S`

### Response Example
```json
{
  "example": "Immutable reference to the socket"
}
```

## get_mut

### Description
Provides a mutable reference to the underlying socket.

### Method
`fn get_mut(&mut self) -> &mut S`

### Response Example
```json
{
  "example": "Mutable reference to the socket"
}
```
```

--------------------------------

### Get DHT Entries

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Retrieves Distributed Hash Table (DHT) entries. The structure of the returned DHT entries depends on the router version.

```APIDOC
## get_dht

### Description
Retrieves Distributed Hash Table (DHT) entries from the Yggdrasil network. The format of the DHT data may vary based on the router version.

### Method
```
pub async fn get_dht(&mut self) -> RequestResult<Vec<DHTEntry>>
```

### Returns
- `RequestResult<Vec<DHTEntry>>`: A result containing a vector of `DHTEntry` objects, or an error. For older router versions, the DHT is returned as a HashMap, which is then converted to a Vec. For newer versions, it's directly a Vec.
```

--------------------------------

### Live Test Request with Tokio

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html

Executes a request to the Yggdrasil socket using Tokio for asynchronous operations. Requires the 'use_tokio' feature.

```rust
use super::*;
const SOCKET_PATH: &str = env!("YGGDRASIL_SOCKET");

#[tokio::test]
async fn test_request() {
    let e = tokio::net::UnixStream::connect(SOCKET_PATH).await.unwrap();
    request(e).await;
}
```

--------------------------------

### TunEntry Serialize Implementation

Source: https://docs.rs/yggdrasilctl/latest/yggdrasilctl/struct.TunEntry.html?search=

Implements the Serialize trait for TunEntry, allowing it to be serialized into various data formats using Serde.

```rust
fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where
    __S: Serializer,
```

--------------------------------

### Live Test with Futures UnixStream

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/lib.rs.html?search=std%3A%3Avec

Connects to the Yggdrasil daemon using the futures crate's UnixStream wrapper and performs various requests. This test requires the 'use_futures' feature to be enabled.

```rust
    #[cfg(feature = "use_futures")]
    #[test]
    fn test_request() {
        let e = futures::io::AllowStdIo::new(
            std::os::unix::net::UnixStream::connect(SOCKET_PATH).unwrap(),
        );
        futures::executor::block_on(request(e));
    }
```

--------------------------------

### Get Peers

Source: https://docs.rs/yggdrasilctl/latest/src/yggdrasilctl/interface.rs.html

Retrieves a list of connected peers and their associated information. The structure of the returned peer data varies slightly depending on the router version.

```APIDOC
## get_peers

### Description
Retrieves a list of connected peers and their associated information. The structure of the returned peer data varies slightly depending on the router version.

### Method
`get_peers()`

### Parameters
None

### Response
- `RequestResult<Vec<PeerEntry>>`: A result containing either an error or a vector of `PeerEntry` objects.

### Response Example (v0.4.5__v0_4.7)
```json
{
  "peers": [
    {
      "address": "2001:db8::1",
      "key": "some_key",
      "port": 12345,
      "remote": "192.168.1.1:12345",
      "uptime": 12345.67,
      "bytes_recvd": 1000000,
      "bytes_sent": 2000000
    }
  ]
}
```

### Response Example (v0.5.0__)
```json
{
  "peers": [
    {
      "address": "2001:db8::1",
      "key": "some_key",
      "port": 12345,
      "remote": "192.168.1.1:12345",
      "uptime": 12345.67,
      "bytes_recvd": 1000000,
      "bytes_sent": 2000000,
      "priority": 10,
      "up": true,
      "inbound": false,
      "latency": 50,
      "last_error": null,
      "last_error_time": null,
      "cost": 100,
      "rate_recvd": 1000,
      "rate_sent": 2000
    }
  ]
}
```
```
Tokens:
Raw