liz/veilid
1
0
Fork 0
Code Pull Requests Packages Releases Activity

more refactor

Browse Source
This commit is contained in:
John Smith
2022-01-03 16:29:04 -05:00
parent 94772094c5
commit 55a44e0c8f
18 changed files with 261 additions and 239 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
veilid-core/src/intf/native/network/mod.rs
View File

@@ -261,13 +261,13 @@ impl Network {
match &dial_info {
DialInfo::UDP(_) => {
let peer_socket_addr = dial_info.to_socket_addr();
RawUdpProtocolHandler::send_unbound_message(data, peer_socket_addr)
RawUdpProtocolHandler::send_unbound_message(peer_socket_addr, data)
.await
.map_err(logthru_net!())
}
DialInfo::TCP(_) => {
let peer_socket_addr = dial_info.to_socket_addr();
RawTcpProtocolHandler::send_unbound_message(data, peer_socket_addr)
RawTcpProtocolHandler::send_unbound_message(peer_socket_addr, data)
.await
.map_err(logthru_net!())
}
@@ -278,78 +278,40 @@ impl Network {
}
}
// Initiate a new low-level protocol connection to a node
pub async fn connect_to_dial_info(
&self,
local_addr: Option<SocketAddr>,
dial_info: &DialInfo,
) -> Result<NetworkConnection, String> {
let connection_manager = self.connection_manager();
let peer_socket_addr = dial_info.to_socket_addr();
Ok(match &dial_info {
DialInfo::UDP(_) => {
panic!("Do not attempt to connect to UDP dial info")
}
DialInfo::TCP(_) => {
let local_addr =
self.get_preferred_local_address(self.inner.lock().tcp_port, &peer_socket_addr);
RawTcpProtocolHandler::connect(connection_manager, local_addr, dial_info)
.await
.map_err(logthru_net!())?
}
DialInfo::WS(_) => {
let local_addr =
self.get_preferred_local_address(self.inner.lock().ws_port, &peer_socket_addr);
WebsocketProtocolHandler::connect(connection_manager, local_addr, dial_info)
.await
.map_err(logthru_net!(error))?
}
DialInfo::WSS(_) => {
let local_addr =
self.get_preferred_local_address(self.inner.lock().wss_port, &peer_socket_addr);
WebsocketProtocolHandler::connect(connection_manager, local_addr, dial_info)
.await
.map_err(logthru_net!(error))?
}
})
}
async fn send_data_to_existing_connection(
&self,
descriptor: &ConnectionDescriptor,
data: Vec<u8>,
) -> Result<Option<Vec<u8>>, String> {
match descriptor.protocol_type() {
ProtocolType::UDP => {
// send over the best udp socket we have bound since UDP is not connection oriented
let peer_socket_addr = descriptor.remote.to_socket_addr();
if let Some(ph) = self.find_best_udp_protocol_handler(
&peer_socket_addr,
&descriptor.local.map(|sa| sa.to_socket_addr()),
) {
ph.clone()
.send_message(data, peer_socket_addr)
.await
.map_err(logthru_net!())?;
// Data was consumed
return Ok(None);
}
}
ProtocolType::TCP | ProtocolType::WS | ProtocolType::WSS => {
// find an existing connection in the connection table if one exists
if let Some(conn) = self.connection_manager().get_connection(descriptor) {
// connection exists, send over it
conn.send(data).await.map_err(logthru_net!())?;
// Data was consumed
return Ok(None);
}
// Handle connectionless protocol
if descriptor.protocol_type() == ProtocolType::UDP {
// send over the best udp socket we have bound since UDP is not connection oriented
let peer_socket_addr = descriptor.remote.to_socket_addr();
if let Some(ph) = self.find_best_udp_protocol_handler(
&peer_socket_addr,
&descriptor.local.map(|sa| sa.to_socket_addr()),
) {
ph.clone()
.send_message(data, peer_socket_addr)
.await
.map_err(logthru_net!())?;
// Data was consumed
return Ok(None);
}
}
// connection or local socket didn't exist, we'll need to use dialinfo to create one
// Pass the data back out so we don't own it any more
Ok(Some(data))
// Handle connection-oriented protocols
if let Some(conn) = self.connection_manager().get_connection(descriptor) {
// connection exists, send over it
conn.send(data).await.map_err(logthru_net!())?;
// Data was consumed
Ok(None)
} else {
// Connection or didn't exist
// Pass the data back out so we don't own it any more
Ok(Some(data))
}
}
// Send data directly to a dial info, possibly without knowing which node it is going to
@@ -372,7 +334,11 @@ impl Network {
}
// Handle connection-oriented protocols
let conn = self.connect_to_dial_info(dial_info).await?;
let local_addr = self.get_preferred_local_address(dial_info);
let conn = self
.connection_manager()
.get_or_create_connection(Some(local_addr), dial_info.clone())
.await?;
conn.send(data).await.map_err(logthru_net!(error))
}
@@ -405,25 +371,7 @@ impl Network {
.ok_or_else(|| "couldn't send data, no dial info or peer address".to_owned())?;
// Handle connectionless protocol
if dial_info.protocol_type() == ProtocolType::UDP {
let peer_socket_addr = dial_info.to_socket_addr();
if let Some(ph) = self.find_best_udp_protocol_handler(&peer_socket_addr, &None) {
return ph
.send_message(data, peer_socket_addr)
.await
.map_err(logthru_net!());
}
return Err("no appropriate UDP protocol handler for dial_info".to_owned())
.map_err(logthru_net!(error));
}
// Handle connection-oriented protocols
let local_addr = self.get_preferred_local_address(&dial_info);
let conn = self
.connection_manager()
.get_or_create_connection(dial_info, Some(local_addr)); xxx implement this and pass thru to NetworkConnection::connect
conn.send(data).await.map_err(logthru_net!(error))
self.send_data_to_dial_info(&dial_info, data).await
}
/////////////////////////////////////////////////////////////////

12
veilid-core/src/intf/native/network/network_tcp.rs
View File

@@ -134,8 +134,8 @@ impl Network {
// and the number of total connections
let addr = match tcp_stream.peer_addr() {
Ok(addr) => addr,
Err(err) => {
error!("failed to get peer address: {}", err);
Err(e) => {
error!("failed to get peer address: {}", e);
return;
}
};
@@ -191,7 +191,9 @@ impl Network {
};
// Register the new connection in the connection manager
connection_manager.on_new_connection(conn).await;
if let Err(e) = connection_manager.on_new_connection(conn).await {
error!("failed to register new connection: {}", e);
}
})
.await;
trace!("exited incoming loop for {}", addr);
@@ -248,7 +250,7 @@ impl Network {
ls.write()
.tls_protocol_handlers
.push(new_protocol_accept_handler(
self.connection_manager(),
self.network_manager().config(),
true,
addr,
));
@@ -256,7 +258,7 @@ impl Network {
ls.write()
.protocol_handlers
.push(new_protocol_accept_handler(
self.connection_manager(),
self.network_manager().config(),
false,
addr,
));

30
veilid-core/src/intf/native/network/network_udp.rs
View File

@@ -21,6 +21,7 @@ impl Network {
////////////////////////////////////////////////////////////
// Run thread task to process stream of messages
let this = self.clone();
let jh = spawn(async move {
trace!("UDP listener task spawned");
@@ -41,8 +42,26 @@ impl Network {
// Spawn a local async task for each socket
let mut protocol_handlers_unordered = stream::FuturesUnordered::new();
let network_manager = this.network_manager();
for ph in protocol_handlers {
let jh = spawn_local(ph.clone().receive_loop());
let network_manager = network_manager.clone();
let jh = spawn_local(async move {
let mut data = vec![0u8; 65536];
while let Ok((size, descriptor)) = ph.recv_message(&mut data).await {
// XXX: Limit the number of packets from the same IP address?
log_net!("UDP packet: {:?}", descriptor);
if let Err(e) = network_manager
.on_recv_envelope(&data[..size], &descriptor)
.await
{
log_net!(error "failed to process received udp envelope: {}", e);
}
}
});
protocol_handlers_unordered.push(jh);
}
// Now we wait for any join handle to exit,
@@ -83,8 +102,7 @@ impl Network {
let socket_arc = Arc::new(udp_socket);
// Create protocol handler
let udpv4_handler =
RawUdpProtocolHandler::new(inner.network_manager.clone(), socket_arc);
let udpv4_handler = RawUdpProtocolHandler::new(socket_arc);
inner.outbound_udpv4_protocol_handler = Some(udpv4_handler);
}
@@ -98,8 +116,7 @@ impl Network {
let socket_arc = Arc::new(udp_socket);
// Create protocol handler
let udpv6_handler =
RawUdpProtocolHandler::new(inner.network_manager.clone(), socket_arc);
let udpv6_handler = RawUdpProtocolHandler::new(socket_arc);
inner.outbound_udpv6_protocol_handler = Some(udpv6_handler);
}
@@ -119,8 +136,7 @@ impl Network {
let socket_arc = Arc::new(udp_socket);
// Create protocol handler
let protocol_handler =
RawUdpProtocolHandler::new(self.inner.lock().network_manager.clone(), socket_arc);
let protocol_handler = RawUdpProtocolHandler::new(socket_arc);
// Create message_handler records
self.inner

42
veilid-core/src/intf/native/network/protocol/mod.rs
View File

@@ -3,28 +3,11 @@ pub mod udp;
pub mod wrtc;
pub mod ws;
use crate::connection_manager::*;
use crate::xx::*;
use crate::*;
use socket2::{Domain, Protocol, Socket, Type};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DummyNetworkConnection {}
impl DummyNetworkConnection {
pub fn connection_descriptor(&self) -> ConnectionDescriptor {
ConnectionDescriptor::new_no_local(PeerAddress::new(
SocketAddress::default(),
ProtocolType::UDP,
))
}
pub async fn send(&self, _message: Vec<u8>) -> Result<(), String> {
Ok(())
}
pub async fn recv(&self) -> Result<Vec<u8>, String> {
Ok(Vec::new())
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum NetworkConnection {
Dummy(DummyNetworkConnection),
@@ -52,6 +35,29 @@ impl NetworkConnection {
}
}
}
pub async fn send_unbound_message(
&self,
dial_info: &DialInfo,
data: Vec<u8>,
) -> Result<(), String> {
match dial_info.protocol_type() {
ProtocolType::UDP => {
let peer_socket_addr = dial_info.to_socket_addr();
udp::RawUdpProtocolHandler::send_unbound_message(peer_socket_addr, data)
.await
.map_err(logthru_net!())
}
ProtocolType::TCP => {
let peer_socket_addr = dial_info.to_socket_addr();
tcp::RawTcpProtocolHandler::send_unbound_message(peer_socket_addr, data)
.await
.map_err(logthru_net!())
}
ProtocolType::WS | ProtocolType::WSS => {
ws::WebsocketProtocolHandler::send_unbound_message(dial_info, data).await
}
}
}
pub fn connection_descriptor(&self) -> ConnectionDescriptor {
match self {

32
veilid-core/src/intf/native/network/protocol/tcp.rs
View File

@@ -1,5 +1,4 @@
use super::*;
use crate::connection_manager::*;
use crate::intf::native::utils::async_peek_stream::*;
use crate::intf::*;
use crate::network_manager::MAX_MESSAGE_SIZE;
@@ -104,7 +103,6 @@ impl RawTcpNetworkConnection {
///
struct RawTcpProtocolHandlerInner {
connection_manager: ConnectionManager,
local_address: SocketAddr,
}
@@ -117,22 +115,13 @@ where
}
impl RawTcpProtocolHandler {
fn new_inner(
connection_manager: ConnectionManager,
local_address: SocketAddr,
) -> RawTcpProtocolHandlerInner {
RawTcpProtocolHandlerInner {
connection_manager,
local_address,
}
fn new_inner(local_address: SocketAddr) -> RawTcpProtocolHandlerInner {
RawTcpProtocolHandlerInner { local_address }
}
pub fn new(connection_manager: ConnectionManager, local_address: SocketAddr) -> Self {
pub fn new(local_address: SocketAddr) -> Self {
Self {
inner: Arc::new(Mutex::new(Self::new_inner(
connection_manager,
local_address,
))),
inner: Arc::new(Mutex::new(Self::new_inner(local_address))),
}
}
@@ -153,10 +142,7 @@ impl RawTcpProtocolHandler {
SocketAddress::from_socket_addr(socket_addr),
ProtocolType::TCP,
);
let (network_manager, local_address) = {
let inner = self.inner.lock();
(inner.connection_manager.clone(), inner.local_address)
};
let local_address = self.inner.lock().local_address;
let conn = NetworkConnection::RawTcp(RawTcpNetworkConnection::new(
stream,
ConnectionDescriptor::new(peer_addr, SocketAddress::from_socket_addr(local_address)),
@@ -194,12 +180,8 @@ impl RawTcpProtocolHandler {
.map_err(map_to_string)
.map_err(logthru_net!("could not get local address from TCP stream"))?;
let ps = AsyncPeekStream::new(ts);
let peer_addr = PeerAddress::new(
SocketAddress::from_socket_addr(remote_socket_addr),
ProtocolType::TCP,
);
// Wrap the stream in a network connection and register it
// Wrap the stream in a network connection and return it
let conn = NetworkConnection::RawTcp(RawTcpNetworkConnection::new(
ps,
ConnectionDescriptor {
@@ -211,8 +193,8 @@ impl RawTcpProtocolHandler {
}
pub async fn send_unbound_message(
data: Vec<u8>,
socket_addr: SocketAddr,
data: Vec<u8>,
) -> Result<(), String> {
if data.len() > MAX_MESSAGE_SIZE {
return Err("sending too large unbound TCP message".to_owned());

59
veilid-core/src/intf/native/network/protocol/udp.rs
View File

@@ -1,10 +1,9 @@
use crate::intf::*;
use crate::network_manager::{NetworkManager, MAX_MESSAGE_SIZE};
use crate::network_manager::MAX_MESSAGE_SIZE;
use crate::*;
use async_std::net::*;
struct RawUdpProtocolHandlerInner {
network_manager: NetworkManager,
socket: Arc<UdpSocket>,
}
@@ -14,64 +13,44 @@ pub struct RawUdpProtocolHandler {
}
impl RawUdpProtocolHandler {
fn new_inner(
network_manager: NetworkManager,
socket: Arc<UdpSocket>,
) -> RawUdpProtocolHandlerInner {
RawUdpProtocolHandlerInner {
network_manager,
socket,
}
fn new_inner(socket: Arc<UdpSocket>) -> RawUdpProtocolHandlerInner {
RawUdpProtocolHandlerInner { socket }
}
pub fn new(network_manager: NetworkManager, socket: Arc<UdpSocket>) -> Self {
pub fn new(socket: Arc<UdpSocket>) -> Self {
Self {
inner: Arc::new(Mutex::new(Self::new_inner(network_manager, socket))),
inner: Arc::new(Mutex::new(Self::new_inner(socket))),
}
}
pub async fn receive_loop(self) {
let mut data = vec![0u8; 65536];
pub async fn recv_message(
&self,
data: &mut [u8],
) -> Result<(usize, ConnectionDescriptor), String> {
let socket = self.inner.lock().socket.clone();
while let Ok((size, socket_addr)) = socket.recv_from(&mut data).await {
// XXX: Limit the number of packets from the same IP address?
trace!("UDP packet from: {}", socket_addr);
let (size, remote_addr) = socket.recv_from(data).await.map_err(map_to_string)?;
let _processed = self.clone().on_message(&data[..size], socket_addr).await;
}
}
pub async fn on_message(&self, data: &[u8], remote_addr: SocketAddr) -> Result<bool, String> {
if data.len() > MAX_MESSAGE_SIZE {
if size > MAX_MESSAGE_SIZE {
return Err("received too large UDP message".to_owned());
}
trace!(
"receiving UDP message of length {} from {}",
data.len(),
size,
remote_addr
);
// Process envelope
let (network_manager, socket) = {
let inner = self.inner.lock();
(inner.network_manager.clone(), inner.socket.clone())
};
let peer_addr = PeerAddress::new(
SocketAddress::from_socket_addr(remote_addr),
ProtocolType::UDP,
);
let local_socket_addr = socket.local_addr().map_err(|e| format!("{}", e))?;
network_manager
.on_recv_envelope(
data,
&ConnectionDescriptor::new(
peer_addr,
SocketAddress::from_socket_addr(local_socket_addr),
),
)
.await
let local_socket_addr = socket.local_addr().map_err(map_to_string)?;
let descriptor = ConnectionDescriptor::new(
peer_addr,
SocketAddress::from_socket_addr(local_socket_addr),
);
Ok((size, descriptor))
}
pub async fn send_message(&self, data: Vec<u8>, socket_addr: SocketAddr) -> Result<(), String> {
@@ -100,8 +79,8 @@ impl RawUdpProtocolHandler {
}
pub async fn send_unbound_message(
data: Vec<u8>,
socket_addr: SocketAddr,
data: Vec<u8>,
) -> Result<(), String> {
if data.len() > MAX_MESSAGE_SIZE {
return Err("sending too large unbound UDP message".to_owned())

27
veilid-core/src/intf/native/network/protocol/ws.rs
View File

@@ -1,5 +1,4 @@
use super::*;
use crate::connection_manager::*;
use crate::intf::native::utils::async_peek_stream::*;
use crate::intf::*;
use crate::network_manager::MAX_MESSAGE_SIZE;
@@ -133,7 +132,6 @@ where
///
struct WebsocketProtocolHandlerInner {
tls: bool,
connection_manager: ConnectionManager,
local_address: SocketAddr,
request_path: Vec<u8>,
connection_initial_timeout: u64,
@@ -147,12 +145,7 @@ where
inner: Arc<WebsocketProtocolHandlerInner>,
}
impl WebsocketProtocolHandler {
pub fn new(
connection_manager: ConnectionManager,
tls: bool,
local_address: SocketAddr,
) -> Self {
let config = connection_manager.config();
pub fn new(config: VeilidConfig, tls: bool, local_address: SocketAddr) -> Self {
let c = config.get();
let path = if tls {
format!("GET {}", c.network.protocol.ws.path.trim_end_matches('/'))
@@ -167,7 +160,6 @@ impl WebsocketProtocolHandler {
let inner = WebsocketProtocolHandlerInner {
tls,
connection_manager,
local_address,
request_path: path.as_bytes().to_vec(),
connection_initial_timeout,
@@ -313,6 +305,23 @@ impl WebsocketProtocolHandler {
)))
}
}
pub async fn send_unbound_message(dial_info: &DialInfo, data: Vec<u8>) -> Result<(), String> {
if data.len() > MAX_MESSAGE_SIZE {
return Err("sending too large unbound WS message".to_owned());
}
trace!(
"sending unbound websocket message of length {} to {}",
data.len(),
dial_info,
);
let conn = Self::connect(None, dial_info.clone())
.await
.map_err(|e| format!("failed to connect websocket for unbound message: {}", e))?;
conn.send(data).await
}
}
impl ProtocolAcceptHandler for WebsocketProtocolHandler {

4
veilid-core/src/intf/native/network/start_protocols.rs
View File

@@ -160,7 +160,7 @@ impl Network {
.start_tcp_listener(
listen_address.clone(),
true,
Box::new(|n, t, a| Box::new(WebsocketProtocolHandler::new(n, t, a))),
Box::new(|c, t, a| Box::new(WebsocketProtocolHandler::new(c, t, a))),
)
.await?;
trace!("WSS: listener started");
@@ -222,7 +222,7 @@ impl Network {
.start_tcp_listener(
listen_address.clone(),
false,
Box::new(|n, _, a| Box::new(RawTcpProtocolHandler::new(n, a))),
Box::new(|_, _, a| Box::new(RawTcpProtocolHandler::new(a))),
)
.await?;
trace!("TCP: listener started");

2
veilid-core/src/intf/native/system.rs
View File

@@ -1,3 +1,5 @@
#![allow(dead_code)]
use crate::xx::*;
pub use async_executors::JoinHandle;
use async_executors::{AsyncStd, LocalSpawnHandleExt, SpawnHandleExt};

1
veilid-core/src/intf/native/utils/network_interfaces/mod.rs
View File

@@ -24,6 +24,7 @@ pub enum IfAddr {
V6(Ifv6Addr),
}
#[allow(dead_code)]
impl IfAddr {
pub fn ip(&self) -> IpAddr {
match *self {

2
veilid-core/src/intf/native/utils/network_interfaces/tools.rs
View File

@@ -1,3 +1,5 @@
#![allow(dead_code)]
pub fn convert_to_unsigned_4(x: [i8; 4]) -> [u8; 4] {
let mut out: [u8; 4] = [0u8; 4];
for i in 0..4 {