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

remove owo colors

Browse Source
This commit is contained in:
John Smith
2023-06-25 14:09:22 -04:00
parent 0f3e7010f2
commit 297908796c
21 changed files with 218 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files
veilid-core/src/lib.rs
-1
View File
@@ -97,7 +97,6 @@ use tracing::*;
use veilid_tools::*;
type RkyvDefaultValidator<'t> = rkyv::validation::validators::DefaultValidator<'t>;
use futures_util::stream::FuturesUnordered;
use owo_colors::OwoColorize;
use schemars::{schema_for, JsonSchema};
use serde::*;
use stop_token::*;
veilid-core/src/network_manager/connection_manager.rs
+6 -6
View File
@@ -256,8 +256,8 @@ impl ConnectionManager {
log_net!(
"== get_or_create_connection local_addr={:?} dial_info={:?}",
local_addr.green(),
dial_info.green()
local_addr,
dial_info
);
// Kill off any possibly conflicting connections
@@ -273,8 +273,8 @@ impl ConnectionManager {
{
log_net!(
"== Returning existing connection local_addr={:?} peer_address={:?}",
local_addr.green(),
peer_address.green()
local_addr,
peer_address
);
return Ok(NetworkResult::Value(conn));
@@ -300,8 +300,8 @@ impl ConnectionManager {
{
log_net!(
"== Returning existing connection in race local_addr={:?} peer_address={:?}",
local_addr.green(),
peer_address.green()
local_addr,
peer_address
);
return Ok(NetworkResult::Value(conn));
veilid-core/src/network_manager/direct_boot.rs
+1 -1
View File
@@ -45,7 +45,7 @@ impl NetworkManager {
let out_data: Vec<u8> = network_result_value_or_log!(self
.net()
.send_recv_data_unbound_to_dial_info(dial_info, data, timeout_ms)
.await? =>
.await? => [ format!(": dial_info={}, data.len={}", dial_info, data.len()) ]
{
return Ok(Vec::new());
});
veilid-core/src/network_manager/mod.rs
+5 -6
View File
@@ -845,7 +845,7 @@ impl NetworkManager {
}
/// Called by the RPC handler when we want to issue an direct receipt
#[instrument(level = "trace", skip(self, rcpt_data), err)]
#[instrument(level = "debug", skip(self, rcpt_data), err)]
pub async fn send_out_of_band_receipt(
&self,
dial_info: DialInfo,
@@ -858,11 +858,10 @@ impl NetworkManager {
// should not be subject to our ability to decode it
// Send receipt directly
log_net!(debug "send_out_of_band_receipt: dial_info={}", dial_info);
network_result_value_or_log!(self
.net()
.send_data_unbound_to_dial_info(dial_info, rcpt_data)
.await? => {
.await? => [ format!(": dial_info={}, rcpt_data.len={}", dial_info, rcpt_data.len()) ] {
return Ok(());
}
);
@@ -928,13 +927,13 @@ impl NetworkManager {
// Is this a direct bootstrap request instead of an envelope?
if data[0..4] == *BOOT_MAGIC {
network_result_value_or_log!(self.handle_boot_request(connection_descriptor).await? => {});
network_result_value_or_log!(self.handle_boot_request(connection_descriptor).await? => [ format!(": connection_descriptor={:?}", connection_descriptor) ] {});
return Ok(true);
}
// Is this an out-of-band receipt instead of an envelope?
if data[0..3] == *RECEIPT_MAGIC {
network_result_value_or_log!(self.handle_out_of_band_receipt(data).await => {});
network_result_value_or_log!(self.handle_out_of_band_receipt(data).await => [ format!(": data.len={}", data.len()) ] {});
return Ok(true);
}
@@ -1040,7 +1039,7 @@ impl NetworkManager {
log_net!(debug "failed to forward envelope: {}" ,e);
return Ok(false);
}
} => {
} => [ format!(": relay_nr={}, data.len={}", relay_nr, data.len()) ] {
return Ok(false);
}
);
veilid-core/src/network_manager/native/mod.rs
+2 -1
View File
@@ -515,7 +515,8 @@ impl Network {
network_result_value_or_log!(ph.clone()
.send_message(data.clone(), peer_socket_addr)
.await
.wrap_err("sending data to existing conection")? => { return Ok(Some(data)); } );
.wrap_err("sending data to existing conection")? => [ format!(": data.len={}, descriptor={:?}", data.len(), descriptor) ]
{ return Ok(Some(data)); } );
// Network accounting
self.network_manager()
veilid-core/src/network_manager/native/network_class_discovery.rs
+1 -1
View File
@@ -92,7 +92,7 @@ impl DiscoveryContext {
);
return None;
}
} => {
} => [ format!(": node_ref={}", node_ref) ] {
return None;
}
);
veilid-core/src/network_manager/native/protocol/udp.rs
+1 -1
View File
@@ -28,7 +28,7 @@ impl RawUdpProtocolHandler {
// Check length of reassembled message (same for all protocols)
if message.len() > MAX_MESSAGE_SIZE {
log_net!(debug "{}({}) at {}@{}:{}", "Invalid message".green(), "received too large UDP message", file!(), line!(), column!());
log_net!(debug "{}({}) at {}@{}:{}", "Invalid message", "received too large UDP message", file!(), line!(), column!());
continue;
}
veilid-core/src/network_manager/network_connection.rs
+4 -4
View File
@@ -236,7 +236,7 @@ impl NetworkConnection {
Box::pin(async move {
log_net!(
"== Starting process_connection loop for id={}, {:?}", connection_id,
descriptor.green()
descriptor
);
let network_manager = connection_manager.network_manager();
@@ -249,7 +249,7 @@ impl NetworkConnection {
let new_timer = || {
sleep(connection_manager.connection_inactivity_timeout_ms()).then(|_| async {
// timeout
log_net!("== Connection timeout on {:?}", descriptor.green());
log_net!("== Connection timeout on {:?}", descriptor);
RecvLoopAction::Timeout
})
};
@@ -306,7 +306,7 @@ impl NetworkConnection {
log_net!(debug "Connection closed from: {} ({})", peer_address.socket_address().to_socket_addr(), peer_address.protocol_type());
return RecvLoopAction::Finish;
}
let mut message = network_result_value_or_log!(v => {
let mut message = network_result_value_or_log!(v => [ format!(": protocol_connection={:?}", protocol_connection) ] {
return RecvLoopAction::Finish;
});
@@ -366,7 +366,7 @@ impl NetworkConnection {
log_net!(
"== Connection loop finished descriptor={:?}",
descriptor.green()
descriptor
);
// Let the connection manager know the receive loop exited
veilid-core/src/network_manager/types/dial_info/tcp.rs
+1 -1
View File
@@ -18,4 +18,4 @@ use super::*;
#[archive_attr(repr(C), derive(CheckBytes))]
pub struct DialInfoTCP {
pub socket_address: SocketAddress,
}
}
veilid-core/src/routing_table/mod.rs
+2 -2
View File
@@ -1121,7 +1121,7 @@ impl RoutingTable {
return;
}
Ok(v) => v,
} => {
} => [ format!(": crypto_kind={} node_ref={} wide={}", crypto_kind, node_ref, wide) ] {
return;
});
@@ -1137,7 +1137,7 @@ impl RoutingTable {
continue;
}
Ok(v) => v,
} => {
} => [ format!(": crypto_kind={} closest_nr={} wide={}", crypto_kind, closest_nr, wide) ] {
// Do nothing with non-values
continue;
});
veilid-core/src/rpc_processor/coders/operations/operation_route.rs
+12 -1
View File
@@ -1,6 +1,6 @@
use super::*;
#[derive(Debug, Clone)]
#[derive(Clone)]
pub struct RoutedOperation {
sequencing: Sequencing,
signatures: Vec<Signature>,
@@ -8,6 +8,17 @@ pub struct RoutedOperation {
data: Vec<u8>,
}
impl fmt::Debug for RoutedOperation {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("RoutedOperation")
.field("sequencing", &self.sequencing)
.field("signatures.len", &self.signatures.len())
.field("nonce", &self.nonce)
.field("data(len)", &self.data.len())
.finish()
}
}
impl RoutedOperation {
pub fn new(sequencing: Sequencing, nonce: Nonce, data: Vec<u8>) -> Self {
Self {
veilid-core/src/rpc_processor/mod.rs
+113 -53
View File
@@ -182,7 +182,7 @@ impl<T> Answer<T> {
}
}
/// An operation that has been fully prepared for envelope r
/// An operation that has been fully prepared for envelope
struct RenderedOperation {
/// The rendered operation bytes
message: Vec<u8>,
@@ -200,6 +200,20 @@ struct RenderedOperation {
reply_private_route: Option<PublicKey>,
}
impl fmt::Debug for RenderedOperation {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("RenderedOperation")
.field("message(len)", &self.message.len())
.field("destination_node_ref", &self.destination_node_ref)
.field("node_ref", &self.node_ref)
.field("hop_count", &self.hop_count)
.field("safety_route", &self.safety_route)
.field("remote_private_route", &self.remote_private_route)
.field("reply_private_route", &self.reply_private_route)
.finish()
}
}
/// Node information exchanged during every RPC message
#[derive(Default, Debug, Clone)]
pub struct SenderPeerInfo {
@@ -431,7 +445,7 @@ impl RPCProcessor {
.await
{
Ok(v) => {
let v = network_result_value_or_log!(v => {
let v = network_result_value_or_log!(v => [ format!(": node_id={} count={} fanout={} fanout={} safety_selection={:?}", node_id, count, fanout, timeout_us, safety_selection) ] {
// Any other failures, just try the next node
return Ok(None);
});
@@ -541,8 +555,7 @@ impl RPCProcessor {
.await;
match &out {
Err(e) => {
let msg = format!("RPC Lost ({}): {}", debug_string, e);
log_rpc!(debug "{}", msg.bright_magenta());
log_rpc!(debug "RPC Lost ({}): {}", debug_string, e);
self.record_question_lost(
waitable_reply.send_ts,
waitable_reply.node_ref.clone(),
@@ -552,8 +565,7 @@ impl RPCProcessor {
);
}
Ok(TimeoutOr::Timeout) => {
let msg = format!("RPC Lost ({}): Timeout", debug_string);
log_rpc!(debug "{}", msg.bright_cyan());
log_rpc!(debug "RPC Lost ({}): Timeout", debug_string);
self.record_question_lost(
waitable_reply.send_ts,
waitable_reply.node_ref.clone(),
@@ -1148,17 +1160,31 @@ impl RPCProcessor {
// Send question
let bytes: ByteCount = (message.len() as u64).into();
let send_ts = get_aligned_timestamp();
let send_data_kind = network_result_try!(self
#[allow(unused_variables)]
let message_len = message.len();
let res = self
.network_manager()
.send_envelope(node_ref.clone(), Some(destination_node_ref), message)
.send_envelope(
node_ref.clone(),
Some(destination_node_ref.clone()),
message,
)
.await
.map_err(|e| {
// If we're returning an error, clean up
self.record_send_failure(RPCKind::Question, send_ts, node_ref.clone(), safety_route, remote_private_route);
self.record_send_failure(
RPCKind::Question,
send_ts,
node_ref.clone(),
safety_route,
remote_private_route,
);
RPCError::network(e)
})? => {
})?;
let send_data_kind = network_result_value_or_log!( res => [ format!(": node_ref={}, destination_node_ref={}, message.len={}", node_ref, destination_node_ref, message_len) ] {
// If we couldn't send we're still cleaning up
self.record_send_failure(RPCKind::Question, send_ts, node_ref.clone(), safety_route, remote_private_route);
network_result_raise!(res);
}
);
@@ -1218,17 +1244,31 @@ impl RPCProcessor {
// Send statement
let bytes: ByteCount = (message.len() as u64).into();
let send_ts = get_aligned_timestamp();
let _send_data_kind = network_result_try!(self
#[allow(unused_variables)]
let message_len = message.len();
let res = self
.network_manager()
.send_envelope(node_ref.clone(), Some(destination_node_ref), message)
.send_envelope(
node_ref.clone(),
Some(destination_node_ref.clone()),
message,
)
.await
.map_err(|e| {
// If we're returning an error, clean up
self.record_send_failure(RPCKind::Statement, send_ts, node_ref.clone(), safety_route, remote_private_route);
self.record_send_failure(
RPCKind::Statement,
send_ts,
node_ref.clone(),
safety_route,
remote_private_route,
);
RPCError::network(e)
})? => {
})?;
let _send_data_kind = network_result_value_or_log!( res => [ format!(": node_ref={}, destination_node_ref={}, message.len={}", node_ref, destination_node_ref, message_len) ] {
// If we couldn't send we're still cleaning up
self.record_send_failure(RPCKind::Statement, send_ts, node_ref.clone(), safety_route, remote_private_route);
network_result_raise!(res);
}
);
@@ -1281,16 +1321,31 @@ impl RPCProcessor {
// Send the reply
let bytes: ByteCount = (message.len() as u64).into();
let send_ts = get_aligned_timestamp();
network_result_try!(self.network_manager()
.send_envelope(node_ref.clone(), Some(destination_node_ref), message)
#[allow(unused_variables)]
let message_len = message.len();
let res = self
.network_manager()
.send_envelope(
node_ref.clone(),
Some(destination_node_ref.clone()),
message,
)
.await
.map_err(|e| {
// If we're returning an error, clean up
self.record_send_failure(RPCKind::Answer, send_ts, node_ref.clone(), safety_route, remote_private_route);
self.record_send_failure(
RPCKind::Answer,
send_ts,
node_ref.clone(),
safety_route,
remote_private_route,
);
RPCError::network(e)
})? => {
})?;
let _send_data_kind = network_result_value_or_log!( res => [ format!(": node_ref={}, destination_node_ref={}, message.len={}", node_ref, destination_node_ref, message_len) ] {
// If we couldn't send we're still cleaning up
self.record_send_failure(RPCKind::Answer, send_ts, node_ref.clone(), safety_route, remote_private_route);
network_result_raise!(res);
}
);
@@ -1513,7 +1568,8 @@ impl RPCProcessor {
let rpc_worker_span = span!(parent: None, Level::TRACE, "rpc_worker recv");
// xxx: causes crash (Missing otel data span extensions)
// rpc_worker_span.follows_from(span_id);
let res = match self
network_result_value_or_log!(match self
.process_rpc_message(msg)
.instrument(rpc_worker_span)
.await
@@ -1524,9 +1580,7 @@ impl RPCProcessor {
}
Ok(v) => v,
};
network_result_value_or_log!(res => {});
} => [ format!(": msg.header={:?}", msg.header) ] {});
}
}
@@ -1542,19 +1596,22 @@ impl RPCProcessor {
routing_domain: RoutingDomain,
body: Vec<u8>,
) -> EyreResult<()> {
let header = RPCMessageHeader {
detail: RPCMessageHeaderDetail::Direct(RPCMessageHeaderDetailDirect {
envelope,
peer_noderef,
connection_descriptor,
routing_domain,
}),
timestamp: get_aligned_timestamp(),
body_len: ByteCount::new(body.len() as u64),
};
let msg = RPCMessageEncoded {
header: RPCMessageHeader {
detail: RPCMessageHeaderDetail::Direct(RPCMessageHeaderDetailDirect {
envelope,
peer_noderef,
connection_descriptor,
routing_domain,
}),
timestamp: get_aligned_timestamp(),
body_len: ByteCount::new(body.len() as u64),
},
header,
data: RPCMessageData { contents: body },
};
let send_channel = {
let inner = self.inner.lock();
inner.send_channel.as_ref().unwrap().clone()
@@ -1577,16 +1634,18 @@ impl RPCProcessor {
sequencing: Sequencing,
body: Vec<u8>,
) -> EyreResult<()> {
let header = RPCMessageHeader {
detail: RPCMessageHeaderDetail::SafetyRouted(RPCMessageHeaderDetailSafetyRouted {
direct,
remote_safety_route,
sequencing,
}),
timestamp: get_aligned_timestamp(),
body_len: (body.len() as u64).into(),
};
let msg = RPCMessageEncoded {
header: RPCMessageHeader {
detail: RPCMessageHeaderDetail::SafetyRouted(RPCMessageHeaderDetailSafetyRouted {
direct,
remote_safety_route,
sequencing,
}),
timestamp: get_aligned_timestamp(),
body_len: (body.len() as u64).into(),
},
header,
data: RPCMessageData { contents: body },
};
let send_channel = {
@@ -1612,21 +1671,22 @@ impl RPCProcessor {
safety_spec: SafetySpec,
body: Vec<u8>,
) -> EyreResult<()> {
let header = RPCMessageHeader {
detail: RPCMessageHeaderDetail::PrivateRouted(RPCMessageHeaderDetailPrivateRouted {
direct,
remote_safety_route,
private_route,
safety_spec,
}),
timestamp: get_aligned_timestamp(),
body_len: (body.len() as u64).into(),
};
let msg = RPCMessageEncoded {
header: RPCMessageHeader {
detail: RPCMessageHeaderDetail::PrivateRouted(
RPCMessageHeaderDetailPrivateRouted {
direct,
remote_safety_route,
private_route,
safety_spec,
},
),
timestamp: get_aligned_timestamp(),
body_len: (body.len() as u64).into(),
},
header,
data: RPCMessageData { contents: body },
};
let send_channel = {
let inner = self.inner.lock();
inner.send_channel.as_ref().unwrap().clone()
veilid-core/src/rpc_processor/rpc_route.rs
+1 -1
View File
@@ -360,7 +360,7 @@ impl RPCProcessor {
Ok(NetworkResult::value(route_hop))
}
#[cfg_attr(feature="verbose-tracing", instrument(level = "trace", skip(self, msg), ret, err))]
#[cfg_attr(feature="verbose-tracing", instrument(level = "trace", skip(self), ret, err))]
pub(crate) async fn process_route(
&self,
msg: RPCMessage,
veilid-core/src/rpc_processor/rpc_validate_dial_info.rs
+4 -4
View File
@@ -26,7 +26,7 @@ impl RPCProcessor {
// Send the validate_dial_info request
// This can only be sent directly, as relays can not validate dial info
network_result_value_or_log!(self.statement(Destination::direct(peer), statement)
.await? => {
.await? => [ format!(": peer={} statement={:?}", peer, statement) ] {
return Ok(false);
}
);
@@ -36,7 +36,7 @@ impl RPCProcessor {
ReceiptEvent::ReturnedPrivate { private_route: _ }
| ReceiptEvent::ReturnedInBand { inbound_noderef: _ }
| ReceiptEvent::ReturnedSafety => {
log_net!(debug "validate_dial_info receipt should be returned out-of-band".green());
log_net!(debug "validate_dial_info receipt should be returned out-of-band");
Ok(false)
}
ReceiptEvent::ReturnedOutOfBand => {
@@ -44,7 +44,7 @@ impl RPCProcessor {
Ok(true)
}
ReceiptEvent::Expired => {
log_net!(debug "validate_dial_info receipt expired".green());
log_net!(debug "validate_dial_info receipt expired");
Ok(false)
}
ReceiptEvent::Cancelled => {
@@ -141,7 +141,7 @@ impl RPCProcessor {
// Send the validate_dial_info request
// This can only be sent directly, as relays can not validate dial info
network_result_value_or_log!(self.statement(Destination::direct(peer), statement)
.await? => {
.await? => [ format!(": peer={} statement={:?}", peer, statement) ] {
continue;
}
);
veilid-core/src/storage_manager/get_value.rs
+2 -2
View File
@@ -58,13 +58,13 @@ impl StorageManager {
let vres = rpc_processor
.clone()
.rpc_call_get_value(
Destination::direct(next_node).with_safety(safety_selection),
Destination::direct(next_node.clone()).with_safety(safety_selection),
key,
subkey,
last_descriptor,
)
.await?;
let gva = network_result_value_or_log!(vres => {
let gva = network_result_value_or_log!(vres => [ format!(": next_node={} safety_selection={:?} key={} subkey={}", next_node, safety_selection, key, subkey) ] {
// Any other failures, just try the next node
return Ok(None);
});
veilid-core/src/storage_manager/set_value.rs
+2 -2
View File
@@ -62,7 +62,7 @@ impl StorageManager {
let vres = rpc_processor
.clone()
.rpc_call_set_value(
Destination::direct(next_node).with_safety(safety_selection),
Destination::direct(next_node.clone()).with_safety(safety_selection),
key,
subkey,
value,
@@ -70,7 +70,7 @@ impl StorageManager {
send_descriptor,
)
.await?;
let sva = network_result_value_or_log!(vres => {
let sva = network_result_value_or_log!(vres => [ format!(": next_node={} safety_selection={:?} key={} subkey={} send_descriptor={}", next_node, safety_selection, key, subkey, send_descriptor) ] {
// Any other failures, just try the next node and pretend this one never happened
return Ok(None);
});