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

many fixes for bootstrap and public internet connectivity

Browse Source
This commit is contained in:
John Smith
2022-05-24 17:13:52 -04:00
parent 9a54ee052c
commit 424ceedfd8
26 changed files with 606 additions and 320 deletions
Download Patch File Download Diff File Expand all files Collapse all files

148
veilid-core/src/xx/async_peek_stream.rs
View File

@@ -20,6 +20,96 @@ where
}
}
////////
///
pub struct Peek<'a> {
aps: AsyncPeekStream,
buf: &'a mut [u8],
}
impl Unpin for Peek<'_> {}
impl Future for Peek<'_> {
type Output = std::io::Result<usize>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = &mut *self;
let mut inner = this.aps.inner.lock();
let inner = &mut *inner;
//
let buf_len = this.buf.len();
let mut copy_len = buf_len;
if buf_len > inner.peekbuf_len {
//
inner.peekbuf.resize(buf_len, 0u8);
let mut read_future = inner
.stream
.read(&mut inner.peekbuf.as_mut_slice()[inner.peekbuf_len..buf_len]);
let read_len = match Pin::new(&mut read_future).poll(cx) {
Poll::Pending => {
inner.peekbuf.resize(inner.peekbuf_len, 0u8);
return Poll::Pending;
}
Poll::Ready(Err(e)) => {
return Poll::Ready(Err(e));
}
Poll::Ready(Ok(v)) => v,
};
inner.peekbuf_len += read_len;
inner.peekbuf.resize(inner.peekbuf_len, 0u8);
copy_len = inner.peekbuf_len;
}
this.buf[..copy_len].copy_from_slice(&inner.peekbuf[..copy_len]);
Poll::Ready(Ok(copy_len))
}
}
////////
///
pub struct PeekExact<'a> {
aps: AsyncPeekStream,
buf: &'a mut [u8],
}
impl Unpin for PeekExact<'_> {}
impl Future for PeekExact<'_> {
type Output = std::io::Result<usize>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = &mut *self;
let mut inner = this.aps.inner.lock();
let inner = &mut *inner;
//
let buf_len = this.buf.len();
let mut copy_len = buf_len;
if buf_len > inner.peekbuf_len {
//
inner.peekbuf.resize(buf_len, 0u8);
let mut read_future = inner
.stream
.read_exact(&mut inner.peekbuf.as_mut_slice()[inner.peekbuf_len..buf_len]);
match Pin::new(&mut read_future).poll(cx) {
Poll::Pending => {
inner.peekbuf.resize(inner.peekbuf_len, 0u8);
return Poll::Pending;
}
Poll::Ready(Err(e)) => {
return Poll::Ready(Err(e));
}
Poll::Ready(Ok(())) => (),
};
inner.peekbuf_len = buf_len;
copy_len = inner.peekbuf_len;
}
this.buf[..copy_len].copy_from_slice(&inner.peekbuf[..copy_len]);
Poll::Ready(Ok(copy_len))
}
}
/////////
///
struct AsyncPeekStreamInner {
@@ -50,60 +140,18 @@ impl AsyncPeekStream {
}
}
pub async fn peek(&'_ self, buf: &'_ mut [u8]) -> Result<usize> {
let (mut stream, mut peekbuf, mut peekbuf_len) = {
let inner = self.inner.lock();
(
inner.stream.clone_stream(),
inner.peekbuf.clone(),
inner.peekbuf_len,
)
};
//
let buf_len = buf.len();
let mut copy_len = buf_len;
if buf_len > peekbuf_len {
//
peekbuf.resize(buf_len, 0u8);
let read_len = stream
.read(&mut peekbuf.as_mut_slice()[peekbuf_len..buf_len])
.await?;
peekbuf_len += read_len;
copy_len = peekbuf_len;
pub fn peek<'a>(&'a self, buf: &'a mut [u8]) -> Peek<'a> {
Peek::<'a> {
aps: self.clone(),
buf,
}
buf[..copy_len].copy_from_slice(&peekbuf[..copy_len]);
let mut inner = self.inner.lock();
inner.peekbuf = peekbuf;
inner.peekbuf_len = peekbuf_len;
Ok(copy_len)
}
pub async fn peek_exact(&'_ self, buf: &'_ mut [u8]) -> Result<()> {
let (mut stream, mut peekbuf, mut peekbuf_len) = {
let inner = self.inner.lock();
(
inner.stream.clone_stream(),
inner.peekbuf.clone(),
inner.peekbuf_len,
)
};
//
let buf_len = buf.len();
if buf_len > peekbuf_len {
//
peekbuf.resize(buf_len, 0u8);
stream
.read_exact(&mut peekbuf.as_mut_slice()[peekbuf_len..buf_len])
.await?;
peekbuf_len = buf_len;
pub fn peek_exact<'a>(&'a self, buf: &'a mut [u8]) -> PeekExact<'a> {
PeekExact::<'a> {
aps: self.clone(),
buf,
}
buf.copy_from_slice(&peekbuf[..buf_len]);
let mut inner = self.inner.lock();
inner.peekbuf = peekbuf;
inner.peekbuf_len = peekbuf_len;
Ok(())
}
}

4
veilid-core/src/xx/eventual_value.rs
View File

@@ -62,7 +62,7 @@ pub struct EventualValueFuture<T: Unpin> {
}
impl<T: Unpin> Future for EventualValueFuture<T> {
type Output = ();
type Output = EventualValue<T>;
fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> task::Poll<Self::Output> {
let this = &mut *self;
let out = {
@@ -76,7 +76,7 @@ impl<T: Unpin> Future for EventualValueFuture<T> {
for w in wakers {
w.wake();
}
task::Poll::<Self::Output>::Ready(())
task::Poll::<Self::Output>::Ready(this.eventual.clone())
}
}
}

32
veilid-core/src/xx/log_thru.rs
View File

@@ -97,6 +97,14 @@ macro_rules! log_rtab {
(warn $fmt:literal, $($arg:expr),+) => {
warn!(target:"rtab", $fmt, $($arg),+);
};
(debug $text:expr) => { debug!(
target: "rtab",
"{}",
$text,
)};
(debug $fmt:literal, $($arg:expr),+) => {
debug!(target:"rtab", $fmt, $($arg),+);
};
($text:expr) => {trace!(
target: "rtab",
"{}",
@@ -230,7 +238,7 @@ macro_rules! logthru {
(error $target:literal) => (|e__| {
error!(
target: $target,
"[{}]",
"[{:?}]",
e__,
);
e__
@@ -238,7 +246,7 @@ macro_rules! logthru {
(error $target:literal, $text:literal) => (|e__| {
error!(
target: $target,
"[{}] {}",
"[{:?}] {}",
e__,
$text
);
@@ -247,7 +255,7 @@ macro_rules! logthru {
(error $target:literal, $fmt:literal, $($arg:expr),+) => (|e__| {
error!(
target: $target,
concat!("[{}] ", $fmt),
concat!("[{:?}] ", $fmt),
e__,
$($arg),+
);
@@ -257,7 +265,7 @@ macro_rules! logthru {
(warn $target:literal) => (|e__| {
warn!(
target: $target,
"[{}]",
"[{:?}]",
e__,
);
e__
@@ -265,7 +273,7 @@ macro_rules! logthru {
(warn $target:literal, $text:literal) => (|e__| {
warn!(
target: $target,
"[{}] {}",
"[{:?}] {}",
e__,
$text
);
@@ -274,7 +282,7 @@ macro_rules! logthru {
(warn $target:literal, $fmt:literal, $($arg:expr),+) => (|e__| {
warn!(
target: $target,
concat!("[{}] ", $fmt),
concat!("[{:?}] ", $fmt),
e__,
$($arg),+
);
@@ -284,7 +292,7 @@ macro_rules! logthru {
(debug $target:literal) => (|e__| {
debug!(
target: $target,
"[{}]",
"[{:?}]",
e__,
);
e__
@@ -292,7 +300,7 @@ macro_rules! logthru {
(debug $target:literal, $text:literal) => (|e__| {
debug!(
target: $target,
"[{}] {}",
"[{:?}] {}",
e__,
$text
);
@@ -301,7 +309,7 @@ macro_rules! logthru {
(debug $target:literal, $fmt:literal, $($arg:expr),+) => (|e__| {
debug!(
target: $target,
concat!("[{}] ", $fmt),
concat!("[{:?}] ", $fmt),
e__,
$($arg),+
);
@@ -311,7 +319,7 @@ macro_rules! logthru {
($target:literal) => (|e__| {
trace!(
target: $target,
"[{}]",
"[{:?}]",
e__,
);
e__
@@ -319,7 +327,7 @@ macro_rules! logthru {
($target:literal, $text:literal) => (|e__| {
trace!(
target: $target,
"[{}] {}",
"[{:?}] {}",
e__,
$text
);
@@ -328,7 +336,7 @@ macro_rules! logthru {
($target:literal, $fmt:literal, $($arg:expr),+) => (|e__| {
trace!(
target: $target,
concat!("[{}] ", $fmt),
concat!("[{:?}] ", $fmt),
e__,
$($arg),+
);

25
veilid-core/src/xx/single_shot_eventual.rs
View File

@@ -2,38 +2,43 @@ use super::*;
pub struct SingleShotEventual<T>
where
T: Unpin + Clone,
T: Unpin,
{
eventual: EventualValueClone<T>,
drop_value: T,
eventual: EventualValue<T>,
drop_value: Option<T>,
}
impl<T> Drop for SingleShotEventual<T>
where
T: Unpin + Clone,
T: Unpin,
{
fn drop(&mut self) {
self.eventual.resolve(self.drop_value.clone());
if let Some(drop_value) = self.drop_value.take() {
self.eventual.resolve(drop_value);
}
}
}
impl<T> SingleShotEventual<T>
where
T: Unpin + Clone,
T: Unpin,
{
pub fn new(drop_value: T) -> Self {
pub fn new(drop_value: Option<T>) -> Self {
Self {
eventual: EventualValueClone::new(),
eventual: EventualValue::new(),
drop_value,
}
}
// Can only call this once, it consumes the eventual
pub fn resolve(self, value: T) -> EventualResolvedFuture<EventualValueClone<T>> {
pub fn resolve(mut self, value: T) -> EventualResolvedFuture<EventualValue<T>> {
// If we resolve, we don't want to resolve again to the drop value
self.drop_value = None;
// Resolve to the specified value
self.eventual.resolve(value)
}
pub fn instance(&self) -> EventualValueCloneFuture<T> {
pub fn instance(&self) -> EventualValueFuture<T> {
self.eventual.instance()
}
}