pignet 0.7.3

Netwok crate for use by other crates in the pigg project
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use anyhow::ensure;
use iroh::endpoint::VarInt;
use iroh::{
    endpoint::Connection, Endpoint, EndpointAddr, EndpointId, RelayMode, RelayUrl, SecretKey,
    TransportAddr,
};
use pigdef::config::HardwareConfigMessage::Disconnect;
use pigdef::config::{HardwareConfig, HardwareConfigMessage};
use pigdef::description::HardwareDescription;
use pigdef::net_values::PIGGLET_ALPN;
use std::io;

/// Wait until we receive a message from remote hardware
pub async fn wait_for_remote_message(
    connection: &mut Connection,
) -> Result<HardwareConfigMessage, anyhow::Error> {
    let mut config_receiver = connection.accept_uni().await?;
    let message = config_receiver.read_to_end(4096).await?;
    ensure!(
        !message.is_empty(),
        io::Error::new(io::ErrorKind::BrokenPipe, "Connection closed")
    );

    Ok(postcard::from_bytes(&message)?)
}

/// Send config change received from the GUI to the remote hardware
pub async fn send_config_message(
    connection: &mut Connection,
    config_change_message: &HardwareConfigMessage,
) -> anyhow::Result<()> {
    // open a quick stream to the connected hardware
    let mut config_sender = connection.open_uni().await?;
    // serialize the message
    let content = postcard::to_allocvec(&config_change_message)?;
    // send it to the remotely connected hardware
    config_sender.write_all(&content).await?;
    // close and flush the stream to ensure the message is sent
    config_sender.finish()?;
    Ok(())
}

/// Connect to an Iroh-Net node using the [NodeId] and an optional [RelayUrl]
pub async fn connect(
    endpoint_id: &EndpointId,
    relay: &Option<RelayUrl>,
) -> anyhow::Result<(HardwareDescription, HardwareConfig, Connection)> {
    let secret_key = SecretKey::generate(&mut rand::rng());

    // Build an `Endpoint`, which uses PublicKeys as node identifiers
    let endpoint = Endpoint::builder()
        // The secret key is used to authenticate with other nodes.
        .secret_key(secret_key)
        // Set the ALPN protocols this endpoint will accept on incoming connections
        .alpns(vec![PIGGLET_ALPN.to_vec()])
        // `RelayMode::Default` means that we will use the default relay servers to holepunch and relay.
        .relay_mode(RelayMode::Default)
        .bind()
        .await?;

    // Find my closest relay - maybe set this as a default in the UI but allow used to
    // override it in a text entry box. Leave blank for the user if it fails to get fetched.
    endpoint.online().await;

    let relay_url = relay
        .clone()
        .unwrap_or(endpoint.addr().relay_urls().next().unwrap().clone());
    let addr = EndpointAddr::from_parts(*endpoint_id, vec![TransportAddr::Relay(relay_url)]);

    // Attempt to connect, over the given ALPN, returns a Quinn connection.
    let connection = endpoint.connect(addr, PIGGLET_ALPN).await?;

    // create a uni receiver to receive the hardware description on
    let mut gui_receiver = connection.accept_uni().await?;
    let message = gui_receiver.read_to_end(4096).await?;
    let reply: (HardwareDescription, HardwareConfig) = postcard::from_bytes(&message)?;

    Ok((reply.0, reply.1, connection))
}

/// Inform the device that we are disconnecting from the Iroh connection and close it
pub async fn disconnect(connection: &mut Connection) -> anyhow::Result<()> {
    send_config_message(connection, &Disconnect).await?;
    connection.close(VarInt::from_u32(0u32), "disconnect".as_bytes());
    Ok(())
}