108 lines
No EOL
5 KiB
Rust
108 lines
No EOL
5 KiB
Rust
use std::io;
|
|
use log::{error, info, trace, warn};
|
|
use domo_proto::commands::node_management::NodeManagementCommand;
|
|
use domo_proto::identifier::Identifier;
|
|
use domo_proto::packet::{ToPacket};
|
|
use domo_proto::packet::packet_data::PacketData;
|
|
use crate::{CONFIG, prelude};
|
|
use crate::app::master::Devices;
|
|
use crate::config::node::NodeType;
|
|
use crate::connection::server::Server;
|
|
|
|
pub mod master;
|
|
|
|
impl NodeType {
|
|
pub async fn start(self) -> io::Result<()> {
|
|
match self {
|
|
NodeType::Master { bind } => {
|
|
let mut server = Server::new(
|
|
bind,
|
|
Some(
|
|
Identifier::from(
|
|
hex::decode(CONFIG.with_borrow(|c| c.node.device_id.clone()))
|
|
.map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "could not parse hex"))?
|
|
)
|
|
),
|
|
).await?;
|
|
|
|
info!("Started server at {}", server.sock().local_addr()?);
|
|
|
|
let mut devices = Devices::new();
|
|
|
|
{
|
|
std::fs::write("./register_packet", Into::<Vec<u8>>::into(NodeManagementCommand::RegisterNode {
|
|
device_id: Identifier::from(0x000000AA)
|
|
}.to_packet(
|
|
Identifier::random(),
|
|
server.device_id(),
|
|
Identifier::random(),
|
|
Identifier::default(),
|
|
)))?;
|
|
std::fs::write("./ping_packet", Into::<Vec<u8>>::into(NodeManagementCommand::Ping.to_packet(
|
|
Identifier::from(0x000000AA),
|
|
server.device_id(),
|
|
Identifier::random(),
|
|
Identifier::default(),
|
|
)))?;
|
|
}
|
|
|
|
loop {
|
|
match server.recv_packet().await {
|
|
(Ok(p), Some(s)) => {
|
|
if devices.get_device(p.src).is_none() {
|
|
if let PacketData::NodeManagement(NodeManagementCommand::RegisterNode { device_id }) = p.data {
|
|
let device_id = devices.add_device_auto(s, Some(device_id));
|
|
let _ = server.send(s, NodeManagementCommand::RegisterNode {
|
|
device_id
|
|
}.to_packet(
|
|
server.device_id(),
|
|
device_id,
|
|
Identifier::random(),
|
|
p.packet_id
|
|
)).await;
|
|
} else {
|
|
warn!("{s} is unregistered and tried to send a packet {p:#?}.");
|
|
let _ = server.send(s, prelude::quick_err::errc_not_registered(
|
|
server.device_id(),
|
|
p.src,
|
|
p.packet_id
|
|
)).await;
|
|
continue;
|
|
}
|
|
}
|
|
match p.data {
|
|
PacketData::NodeManagement(NodeManagementCommand::Ping) => {
|
|
trace!("ping from: [{s}->{}]", p.src);
|
|
let _ = server.send(s, NodeManagementCommand::Ping.to_packet(
|
|
server.device_id(),
|
|
p.src,
|
|
Identifier::random(),
|
|
p.packet_id,
|
|
)).await;
|
|
}
|
|
PacketData::NodeManagement(NodeManagementCommand::RegisterNode { .. }) => (),
|
|
_ => warn!("dropped packet")
|
|
}
|
|
}
|
|
(Err(e), Some(source)) => {
|
|
error!("{source} sent intelligible data: {e}");
|
|
let device_id = server.device_id();
|
|
if let Err(e) = server.send(source,
|
|
prelude::quick_err::net_broken_packet(
|
|
device_id,
|
|
Identifier::random(),
|
|
),
|
|
).await {
|
|
error!("could not send error packet: {e}");
|
|
}
|
|
}
|
|
_ => warn!("dropped packet")
|
|
}
|
|
}
|
|
}
|
|
NodeType::Bridge { .. } => {}
|
|
NodeType::Subnet { .. } => {}
|
|
}
|
|
Ok(())
|
|
}
|
|
} |