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

native refactor done

Browse Source
This commit is contained in:
John Smith
2022-01-04 09:53:30 -05:00
parent 8b85c5ec12
commit 2564d35cc1
13 changed files with 124 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -54,7 +54,7 @@ impl Network {
log_net!("UDP packet: {:?}", descriptor);
if let Err(e) = network_manager
.on_recv_envelope(&data[..size], &descriptor)
.on_recv_envelope(&data[..size], descriptor)
.await
{
log_net!(error "failed to process received udp envelope: {}", e);

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

@@ -56,6 +56,16 @@ impl ProtocolNetworkConnection {
}
}
pub async fn close(&mut self) -> Result<(), String> {
match self {
Self::Dummy(d) => d.close(),
Self::RawTcp(t) => t.close().await,
Self::WsAccepted(w) => w.close().await,
Self::Ws(w) => w.close().await,
Self::Wss(w) => w.close().await,
}
}
pub async fn send(&mut self, message: Vec<u8>) -> Result<(), String> {
match self {
Self::Dummy(d) => d.send(message),

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

@@ -3,9 +3,9 @@ use crate::intf::native::utils::async_peek_stream::*;
use crate::intf::*;
use crate::network_manager::MAX_MESSAGE_SIZE;
use crate::*;
use async_std::net::*;
use async_std::prelude::*;
use std::fmt;
use async_std::net::TcpStream;
use core::fmt;
use futures_util::{AsyncReadExt, AsyncWriteExt};
pub struct RawTcpNetworkConnection {
stream: AsyncPeekStream,
@@ -22,6 +22,14 @@ impl RawTcpNetworkConnection {
Self { stream }
}
pub async fn close(&mut self) -> Result<(), String> {
self.stream
.close()
.await
.map_err(map_to_string)
.map_err(logthru_net!())
}
pub async fn send(&mut self, message: Vec<u8>) -> Result<(), String> {
if message.len() > MAX_MESSAGE_SIZE {
return Err("sending too large TCP message".to_owned());
@@ -183,7 +191,7 @@ impl ProtocolAcceptHandler for RawTcpProtocolHandler {
&self,
stream: AsyncPeekStream,
peer_addr: SocketAddr,
) -> SystemPinBoxFuture<Result<Option<NetworkConnection>, String>> {
) -> SystemPinBoxFuture<core::result::Result<Option<NetworkConnection>, String>> {
Box::pin(self.clone().on_accept_async(stream, peer_addr))
}
}

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

@@ -3,16 +3,16 @@ use crate::intf::native::utils::async_peek_stream::*;
use crate::intf::*;
use crate::network_manager::MAX_MESSAGE_SIZE;
use crate::*;
use alloc::sync::Arc;
use async_std::io;
use async_std::net::*;
use async_tls::TlsConnector;
use async_tungstenite::tungstenite::protocol::Message;
use async_tungstenite::{accept_async, client_async, WebSocketStream};
use core::fmt;
use core::time::Duration;
use futures_util::sink::SinkExt;
use futures_util::stream::StreamExt;
use std::fmt;
use std::sync::Arc;
use std::time::Duration;
pub type WebSocketNetworkConnectionAccepted = WebsocketNetworkConnection<AsyncPeekStream>;
pub type WebsocketNetworkConnectionWSS =
@@ -68,6 +68,16 @@ where
}
}
pub async fn close(&self) -> Result<(), String> {
let mut inner = self.inner.lock().await;
inner
.ws_stream
.close(None)
.await
.map_err(map_to_string)
.map_err(logthru_net!(error "failed to close websocket"))
}
pub async fn send(&self, message: Vec<u8>) -> Result<(), String> {
if message.len() > MAX_MESSAGE_SIZE {
return Err("received too large WS message".to_owned());

13
veilid-core/src/intf/wasm/network/protocol/mod.rs
View File

@@ -8,7 +8,7 @@ use crate::xx::*;
#[derive(Debug)]
pub enum ProtocolNetworkConnection {
Dummy(DummyNetworkConnection),
WS(ws::WebsocketNetworkConnection),
Ws(ws::WebsocketNetworkConnection),
//WebRTC(wrtc::WebRTCNetworkConnection),
}
@@ -46,18 +46,23 @@ impl ProtocolNetworkConnection {
}
}
}
pub async fn close(&mut self) -> Result<(), String> {
match self {
Self::Dummy(d) => d.close(),
Self::Ws(w) => w.close().await,
}
}
pub async fn send(&mut self, message: Vec<u8>) -> Result<(), String> {
match self {
Self::Dummy(d) => d.send(message),
Self::WS(w) => w.send(message),
Self::Ws(w) => w.send(message).await,
}
}
pub async fn recv(&mut self) -> Result<Vec<u8>, String> {
match self {
Self::Dummy(d) => d.recv(),
Self::WS(w) => w.recv(),
Self::Ws(w) => w.recv().await,
}
}
}

31
veilid-core/src/intf/wasm/network/protocol/ws.rs
View File

@@ -7,14 +7,14 @@ use web_sys::WebSocket;
use ws_stream_wasm::*;
struct WebsocketNetworkConnectionInner {
ws_meta: WsMeta,
ws_stream: WsStream,
ws: WebSocket,
}
#[derive(Clone)]
pub struct WebsocketNetworkConnection {
tls: bool,
inner: Arc<Mutex<WebsocketNetworkConnectionInner>>,
inner: Arc<AsyncMutex<WebsocketNetworkConnectionInner>>,
}
impl fmt::Debug for WebsocketNetworkConnection {
@@ -24,33 +24,34 @@ impl fmt::Debug for WebsocketNetworkConnection {
}
impl WebsocketNetworkConnection {
pub fn new(tls: bool, ws_stream: WsStream) -> Self {
let ws = ws_stream.wrapped().clone();
pub fn new(tls: bool, ws_meta: WsMeta, ws_stream: WsStream) -> Self {
Self {
tls,
inner: Arc::new(Mutex::new(WebsocketNetworkConnectionInner {
ws_meta,
ws_stream,
ws,
})),
}
}
xxx convert this to async and use stream api not low level websocket
xxx implement close() everywhere and skip using eventual for loop shutdown
pub async fn close(&self) -> Result<(), String> {
let inner = self.inner.lock().await;
inner.ws_meta.close().await;
}
pub fn send(&self, message: Vec<u8>) -> Result<(), String> {
pub async fn send(&self, message: Vec<u8>) -> Result<(), String> {
if message.len() > MAX_MESSAGE_SIZE {
return Err("sending too large WS message".to_owned()).map_err(logthru_net!(error));
}
self.inner
.lock()
.ws
.send_with_u8_array(&message)
let mut inner = self.inner.lock().await;
inner.ws_stream
.send(WsMessage::Binary(message)).await
.map_err(|_| "failed to send to websocket".to_owned())
.map_err(logthru_net!(error))
}
pub fn recv(&self) -> Result<Vec<u8>, String> {
let out = match self.inner.lock().ws_stream.next().await {
pub async fn recv(&self) -> Result<Vec<u8>, String> {
let mut inner = self.inner.lock().await;
let out = match inner.ws_stream.next().await {
Some(WsMessage::Binary(v)) => v,
Some(_) => {
return Err("Unexpected WS message type".to_owned())
@@ -112,7 +113,7 @@ impl WebsocketProtocolHandler {
remote: dial_info.to_peer_address(),
};
Ok(NetworkConnection::from_protocol(descriptor,ProtocolNetworkConnection::WS(WebsocketNetworkConnection::new(tls, wsio))))
Ok(NetworkConnection::from_protocol(descriptor,ProtocolNetworkConnection::Ws(WebsocketNetworkConnection::new(tls, wsio))))
}
pub async fn send_unbound_message(dial_info: &DialInfo, data: Vec<u8>) -> Result<(), String> {