9 changed files with 279 additions and 7 deletions
@ -1 +1,41 @@
|
||||
pub trait Interface {} |
||||
use alloc::string::String; |
||||
use crate::message::MessageBytes; |
||||
use crate::res::IFResult; |
||||
|
||||
|
||||
/// Some data that can be provided to the interface to send the message to a target.
|
||||
///
|
||||
/// For IP this might be `IP:port`.
|
||||
/// Radio interface, for example, may not have the functionality of targeting, but that's fine
|
||||
pub(crate) type TargetingData = String; |
||||
|
||||
/// In an std environment we require that the interface can be send safely between threads
|
||||
#[cfg(not(std))] |
||||
pub trait InterfaceRequirements {} |
||||
#[cfg(std)] |
||||
pub trait InterfaceRequirements = Send + Sync; |
||||
|
||||
|
||||
/// An interface that can be used to
|
||||
pub trait Interface: InterfaceRequirements { |
||||
/// Run one main loop iteration.
|
||||
/// On platforms that support concurrency, these functions will be run simultaneously for all interfaces.
|
||||
/// Most likely, this function will accept messages and save them somewhere internally to give out later in `Interface.receive()`.
|
||||
///
|
||||
/// For systems that don't support concurrency, there can be only one interface in this function waits for a message (to avoid blocking).
|
||||
/// That's why it's necessary to check if it is the case for this interface, and it's done using function `Interface::has_blocking_main()`
|
||||
fn main_loop_iteration(&mut self) -> IFResult<()>; |
||||
/// Check if `main_loop_iteration` stops execution and waits for a message
|
||||
fn has_blocking_main(&self) -> bool { |
||||
false // hopefully...
|
||||
} |
||||
/// Get some way of identification for this interface
|
||||
fn id(&self) -> &str; |
||||
/// Send a message. If no `interface_data` is provided, we should consider it to be a broadcast.
|
||||
/// If, on the other hand, `interface_data` is not `None`, it should be used to send the message to the target.
|
||||
fn send(&mut self, message: &[u8] /*MessageBytes*/, interface_data: Option<TargetingData>) -> IFResult<()>; |
||||
/// Receive a message through this interface. Returns a result with an option of (message bytes, target).
|
||||
/// `None` means there is no message available at the time.
|
||||
/// The implementations of this function shouldn't wait for new messages, but
|
||||
fn receive(&mut self) -> IFResult<Option<(MessageBytes, TargetingData /*interface data*/)>>; |
||||
} |
||||
|
||||
@ -0,0 +1,6 @@
|
||||
use crate::interface::Interface; |
||||
use alloc::vec; |
||||
|
||||
pub fn get_interfaces() -> alloc::vec::Vec<alloc::boxed::Box<dyn Interface>> { |
||||
vec![] |
||||
} |
||||
@ -0,0 +1,5 @@
|
||||
use alloc::vec::Vec; |
||||
|
||||
|
||||
/// A serialized message
|
||||
pub(crate) type MessageBytes = Vec<u8>; |
||||
@ -0,0 +1,19 @@
|
||||
use alloc::format; |
||||
use alloc::string::String; |
||||
use core::fmt::Debug; |
||||
|
||||
/// An enum for all errors that may occur
|
||||
pub enum IFError { |
||||
/// An error that was created in some dependency and then converted to `IFError`
|
||||
General(String), |
||||
} |
||||
|
||||
|
||||
impl<T: Debug> From<T> for IFError { |
||||
/// Convert from other error
|
||||
fn from(e: T) -> Self { |
||||
Self::General(format!("{:?}", e)) |
||||
} |
||||
} |
||||
|
||||
pub type IFResult<T> = Result<T, IFError>; |
||||
@ -1 +1,95 @@
|
||||
use alloc::boxed::Box; |
||||
use alloc::string::String; |
||||
use alloc::vec::Vec; |
||||
use crate::interface::{Interface, TargetingData}; |
||||
use crate::message::MessageBytes; |
||||
use crate::res::IFResult; |
||||
|
||||
#[cfg(std)] |
||||
use rayon::prelude::*; |
||||
|
||||
|
||||
/// An identification of a peer - something that we can use to send a message to id
|
||||
#[derive(Clone, Debug)] |
||||
pub struct PeerInfo { |
||||
/// Something to locally identify this peer
|
||||
pub peer_id: u64, |
||||
/// ID of the interface through which we communicate with this peer
|
||||
pub interface_id: String, |
||||
/// Data that should be passed to the interface to send a message to this peer
|
||||
pub interface_targeting_data: TargetingData, |
||||
} |
||||
|
||||
impl PeerInfo { |
||||
fn new(interface_id: String, interface_targeting_data: TargetingData) -> Self { |
||||
Self { |
||||
peer_id: rand::random(), |
||||
interface_id, |
||||
interface_targeting_data, |
||||
} |
||||
} |
||||
} |
||||
|
||||
|
||||
/// The struct that manages all the communication with peers
|
||||
pub struct Transport { |
||||
pub interfaces: Vec<Box<dyn Interface>>, |
||||
peers: Vec<PeerInfo>, |
||||
} |
||||
|
||||
impl Transport { |
||||
/// Find a peer in `self.peers` by its id
|
||||
fn get_peer_by_id(&self, peer_id: u64) -> Option<PeerInfo> { |
||||
self.peers.iter().find(|peer| peer.peer_id == peer_id).cloned() |
||||
} |
||||
|
||||
/// Try to find a peer in `self.peers` by interface_id and targeting data
|
||||
fn get_peer_by_parameters(&self, interface_id: &str, data: &str /*&TargetingData*/) -> Option<&PeerInfo> { |
||||
self.peers.iter().find(|peer| peer.interface_id == interface_id && peer.interface_targeting_data == data) |
||||
} |
||||
|
||||
/// Insert a new peer into out database and return its id or find an existing one with these parameters
|
||||
fn find_or_add_peer(&mut self, interface_id: String, data: TargetingData) -> u64 { |
||||
match self.get_peer_by_parameters(interface_id.as_str(), &data) { |
||||
None => { |
||||
let new_peer = PeerInfo::new(interface_id, data); |
||||
let peer_id = new_peer.peer_id; |
||||
self.peers.push(new_peer); |
||||
peer_id |
||||
} |
||||
Some(peer) => peer.peer_id |
||||
} |
||||
} |
||||
|
||||
/// Get interface index by its ID
|
||||
fn interface_index_by_id(&self, interface_id: &str) -> usize { |
||||
self.interfaces.iter().position(|interface| interface.id() == interface_id).unwrap_or_else(|| panic!("Invalid interface id")) |
||||
} |
||||
|
||||
/// Send message bytes to a peer if data is provided or broadcast the data if `peer == None`
|
||||
pub fn send_message(&mut self, message: MessageBytes, peer_id: Option<u64>) -> IFResult<()> { |
||||
let peer = if let Some(peer_id) = peer_id { self.get_peer_by_id(peer_id) } else { None }; |
||||
match peer { |
||||
// Broadcast
|
||||
None => { |
||||
#[cfg(not(std))] |
||||
{ |
||||
for interface in &mut self.interfaces { |
||||
interface.send(&message, None)?; |
||||
} |
||||
} |
||||
// If we have concurrency, we will do it concurrently
|
||||
#[cfg(std)] |
||||
{ |
||||
self.interfaces.par_iter_mut().map(|interface| interface.send(&message, None)).for_each(drop); |
||||
} |
||||
Ok(()) |
||||
} |
||||
// Singlecast
|
||||
Some(peer) => { |
||||
let interface_ind = self.interface_index_by_id(peer.interface_id.as_str()); |
||||
self.interfaces[interface_ind].send(&message, Some(peer.interface_targeting_data)) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
Loading…
Reference in new issue