super_cereal 0.1.0

Proxy a serial port over the network using RustDDS (UART over LAN)
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

mod bridge;
mod cli;
mod message;
mod pty;
mod serial;
mod transport;

use anyhow::Result;
use clap::Parser;
use cli::{Cli, Commands};
use tracing::info;
use tracing_subscriber::EnvFilter;

#[tokio::main]
async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
        )
        .init();

    let cli = Cli::parse();

    match cli.command {
        Commands::Serve {
            port,
            baud,
            channel,
            domain,
        } => run_serve(port, baud, channel, domain).await,
        Commands::Attach {
            channel,
            link,
            domain,
        } => run_attach(channel, link, domain).await,
        Commands::List { domain, wait } => run_list(domain, wait).await,
    }
}

async fn run_serve(
    port: std::path::PathBuf,
    baud: u32,
    channel: String,
    domain: u16,
) -> Result<()> {
    info!(
        port = %port.display(),
        baud,
        channel,
        domain,
        "starting serve"
    );

    let participant = transport::DdsParticipant::new(domain)?;
    let dds_channel = transport::DdsChannel::open(&participant.participant, &channel)?;
    let serial = serial::open_serial(&port, baud).await?;

    tokio::select! {
        res = bridge::run_serve_bridge(serial, dds_channel) => res?,
        res = transport::wait_for_shutdown() => {
            res?;
        }
    }

    Ok(())
}

async fn run_attach(
    channel: String,
    link: std::path::PathBuf,
    domain: u16,
) -> Result<()> {
    info!(channel, link = %link.display(), domain, "starting attach");

    let endpoint = pty::create_pty_endpoint(&link)?;
    let link_path = endpoint.link_path.clone();
    let participant = transport::DdsParticipant::new(domain)?;
    let dds_channel = transport::DdsChannel::open(&participant.participant, &channel)?;

    let bridge_result = tokio::select! {
        res = bridge::run_attach_bridge(endpoint.async_io, dds_channel) => res,
        res = transport::wait_for_shutdown() => {
            res?;
            pty::cleanup_link(&link_path).await?;
            return Ok(());
        }
    };

    bridge_result?;
    pty::cleanup_link(&link_path).await?;

    Ok(())
}

async fn run_list(domain: u16, wait: u64) -> Result<()> {
    let participant = transport::DdsParticipant::new(domain)?;
    let channels = transport::discover_channels(&participant.participant, wait).await?;

    if channels.is_empty() {
        println!("No super_cereal channels discovered.");
    } else {
        for channel in channels {
            println!("{channel}");
        }
    }

    Ok(())
}