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

flutter and macos work

Browse Source
This commit is contained in:
John Smith
2022-06-10 17:07:10 -04:00
parent 86567ea78d
commit 5931f1254f
33 changed files with 312 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
veilid-core/ios_build.sh
View File

@@ -15,8 +15,8 @@ do
if [ "$arch" == "arm64" ]; then
echo arm64
CARGO_TARGET=aarch64-apple-ios
CARGO_TOOLCHAIN=+ios-arm64-1.57.0
#CARGO_TOOLCHAIN=
#CARGO_TOOLCHAIN=+ios-arm64-1.57.0
CARGO_TOOLCHAIN=
elif [ "$arch" == "x86_64" ]; then
echo x86_64
CARGO_TARGET=x86_64-apple-ios

3
veilid-core/src/api_tracing_layer.rs
View File

@@ -52,6 +52,7 @@ impl ApiTracingLayer {
}
}
#[instrument(level = "debug", skip(update_callback))]
pub async fn init(max_level: Option<VeilidLogLevel>, update_callback: UpdateCallback) {
let api_logger = API_LOGGER.get_or_init(|| ApiTracingLayer {
inner: Arc::new(Mutex::new(None)),
@@ -60,6 +61,7 @@ impl ApiTracingLayer {
*api_logger.inner.lock() = apilogger_inner;
}
#[instrument(level = "debug")]
pub async fn terminate() {
if let Some(api_logger) = API_LOGGER.get() {
let mut inner = api_logger.inner.lock();
@@ -75,6 +77,7 @@ impl ApiTracingLayer {
.clone()
}
#[instrument(level = "trace")]
pub fn change_api_log_level(max_level: Option<VeilidLogLevel>) {
if let Some(api_logger) = API_LOGGER.get() {
if let Some(inner) = &mut *api_logger.inner.lock() {

13
veilid-core/src/attachment_manager.rs
View File

@@ -221,6 +221,7 @@ impl AttachmentManager {
}
}
#[instrument(level = "debug", skip(self))]
async fn attachment_maintainer(self) {
trace!("attachment starting");
let netman = {
@@ -229,7 +230,6 @@ impl AttachmentManager {
inner.network_manager.clone()
};
trace!("starting network");
let mut started = true;
if let Err(err) = netman.startup().await {
error!("network startup failed: {}", err);
@@ -266,6 +266,7 @@ impl AttachmentManager {
self.inner.lock().attach_timestamp = None;
}
#[instrument(level = "debug", skip_all, err)]
pub async fn init(&self, update_callback: UpdateCallback) -> Result<(), String> {
trace!("init");
let network_manager = {
@@ -286,6 +287,8 @@ impl AttachmentManager {
Ok(())
}
#[instrument(level = "debug", skip(self))]
pub async fn terminate(&self) {
// Ensure we detached
self.detach().await;
@@ -298,8 +301,8 @@ impl AttachmentManager {
inner.update_callback = None;
}
#[instrument(level = "trace", skip(self))]
fn attach(&self) {
trace!("attach");
// Create long-running connection maintenance routine
let this = self.clone();
self.inner.lock().maintain_peers = true;
@@ -307,8 +310,8 @@ impl AttachmentManager {
Some(intf::spawn(this.attachment_maintainer()));
}
#[instrument(level = "trace", skip(self))]
async fn detach(&self) {
trace!("detach");
let attachment_maintainer_jh = self.inner.lock().attachment_maintainer_jh.take();
if let Some(jh) = attachment_maintainer_jh {
// Terminate long-running connection maintenance routine
@@ -343,16 +346,18 @@ impl AttachmentManager {
}
}
#[instrument(level = "trace", skip(self), err)]
pub async fn request_attach(&self) -> Result<(), String> {
self.process_input(&AttachmentInput::AttachRequested)
.await
.map_err(|e| format!("Attach request failed: {}", e))
}
#[instrument(level = "trace", skip(self), err)]
pub async fn request_detach(&self) -> Result<(), String> {
self.process_input(&AttachmentInput::DetachRequested)
.await
.map_err(|e| format!("Attach request failed: {}", e))
.map_err(|e| format!("Detach request failed: {}", e))
}
pub fn get_state(&self) -> AttachmentState {

10
veilid-core/src/core_context.rs
View File

@@ -10,7 +10,6 @@ cfg_if! {
if #[cfg(target_arch = "wasm32")] {
pub type UpdateCallback = Arc<dyn Fn(VeilidUpdate)>;
} else {
pub type UpdateCallback = Arc<dyn Fn(VeilidUpdate) + Send + Sync>;
}
}
@@ -59,6 +58,7 @@ impl ServicesContext {
}
}
#[instrument(err, skip_all)]
pub async fn startup(&mut self) -> Result<(), VeilidAPIError> {
let api_log_level: VeilidConfigLogLevel = self.config.get().api_log_level;
if api_log_level != VeilidConfigLogLevel::Off {
@@ -131,6 +131,7 @@ impl ServicesContext {
Ok(())
}
#[instrument(skip_all)]
pub async fn shutdown(&mut self) {
info!("Veilid API shutting down");
@@ -179,6 +180,7 @@ pub struct VeilidCoreContext {
}
impl VeilidCoreContext {
#[instrument(err, skip_all)]
async fn new_with_config_callback(
update_callback: UpdateCallback,
config_callback: ConfigCallback,
@@ -193,6 +195,7 @@ impl VeilidCoreContext {
Self::new_common(update_callback, config).await
}
#[instrument(err, skip(update_callback))]
async fn new_with_config_json(
update_callback: UpdateCallback,
config_json: String,
@@ -206,6 +209,7 @@ impl VeilidCoreContext {
Self::new_common(update_callback, config).await
}
#[instrument(err, skip(update_callback))]
async fn new_common(
update_callback: UpdateCallback,
config: VeilidConfig,
@@ -233,6 +237,7 @@ impl VeilidCoreContext {
})
}
#[instrument(skip_all)]
async fn shutdown(self) {
let mut sc = ServicesContext::new_full(
self.config.clone(),
@@ -251,6 +256,7 @@ impl VeilidCoreContext {
static INITIALIZED: AsyncMutex<bool> = AsyncMutex::new(false);
#[instrument(err, skip_all)]
pub async fn api_startup(
update_callback: UpdateCallback,
config_callback: ConfigCallback,
@@ -273,6 +279,7 @@ pub async fn api_startup(
Ok(veilid_api)
}
#[instrument(err, skip(update_callback))]
pub async fn api_startup_json(
update_callback: UpdateCallback,
config_json: String,
@@ -294,6 +301,7 @@ pub async fn api_startup_json(
Ok(veilid_api)
}
#[instrument(skip_all)]
pub(crate) async fn api_shutdown(context: VeilidCoreContext) {
let mut initialized_lock = INITIALIZED.lock().await;
context.shutdown().await;

9
veilid-core/src/intf/native/protected_store.rs
View File

@@ -29,6 +29,7 @@ impl ProtectedStore {
}
}
#[instrument(level = "trace", skip(self), err)]
pub async fn delete_all(&self) -> Result<(), String> {
// Delete all known keys
if self.remove_user_secret_string("node_id").await? {
@@ -43,6 +44,7 @@ impl ProtectedStore {
Ok(())
}
#[instrument(level = "debug", skip(self), err)]
pub async fn init(&self) -> Result<(), String> {
let delete = {
let c = self.config.get();
@@ -95,6 +97,7 @@ impl ProtectedStore {
Ok(())
}
#[instrument(level = "debug", skip(self))]
pub async fn terminate(&self) {
*self.inner.lock() = Self::new_inner();
}
@@ -108,6 +111,7 @@ impl ProtectedStore {
}
}
#[instrument(level = "trace", skip(self, value), ret, err)]
pub async fn save_user_secret_string(&self, key: &str, value: &str) -> Result<bool, String> {
let inner = self.inner.lock();
inner
@@ -124,6 +128,7 @@ impl ProtectedStore {
.map_err(logthru_pstore!())
}
#[instrument(level = "trace", skip(self), err)]
pub async fn load_user_secret_string(&self, key: &str) -> Result<Option<String>, String> {
let inner = self.inner.lock();
match inner
@@ -139,6 +144,7 @@ impl ProtectedStore {
}
}
#[instrument(level = "trace", skip(self), ret, err)]
pub async fn remove_user_secret_string(&self, key: &str) -> Result<bool, String> {
let inner = self.inner.lock();
match inner
@@ -154,6 +160,7 @@ impl ProtectedStore {
}
}
#[instrument(level = "trace", skip(self, value), ret, err)]
pub async fn save_user_secret(&self, key: &str, value: &[u8]) -> Result<bool, String> {
let mut s = BASE64URL_NOPAD.encode(value);
s.push('!');
@@ -161,6 +168,7 @@ impl ProtectedStore {
self.save_user_secret_string(key, s.as_str()).await
}
#[instrument(level = "trace", skip(self), err)]
pub async fn load_user_secret(&self, key: &str) -> Result<Option<Vec<u8>>, String> {
let mut s = match self.load_user_secret_string(key).await? {
Some(s) => s,
@@ -191,6 +199,7 @@ impl ProtectedStore {
}
}
#[instrument(level = "trace", skip(self), ret, err)]
pub async fn remove_user_secret(&self, key: &str) -> Result<bool, String> {
self.remove_user_secret_string(key).await
}

36
veilid-core/src/network_manager/mod.rs
View File

@@ -233,6 +233,7 @@ impl NetworkManager {
self.inner.lock().relay_node.clone()
}
#[instrument(level = "debug", skip_all, err)]
pub async fn init(&self, update_callback: UpdateCallback) -> Result<(), String> {
let routing_table = RoutingTable::new(self.clone());
routing_table.init().await?;
@@ -240,6 +241,8 @@ impl NetworkManager {
self.inner.lock().update_callback = Some(update_callback);
Ok(())
}
#[instrument(level = "debug", skip_all)]
pub async fn terminate(&self) {
let routing_table = {
let mut inner = self.inner.lock();
@@ -251,6 +254,7 @@ impl NetworkManager {
self.inner.lock().update_callback = None;
}
#[instrument(level = "debug", skip_all, err)]
pub async fn internal_startup(&self) -> Result<(), String> {
trace!("NetworkManager::internal_startup begin");
if self.inner.lock().components.is_some() {
@@ -281,6 +285,7 @@ impl NetworkManager {
Ok(())
}
#[instrument(level = "debug", skip_all, err)]
pub async fn startup(&self) -> Result<(), String> {
if let Err(e) = self.internal_startup().await {
self.shutdown().await;
@@ -292,6 +297,7 @@ impl NetworkManager {
Ok(())
}
#[instrument(level = "debug", skip_all)]
pub async fn shutdown(&self) {
trace!("NetworkManager::shutdown begin");
@@ -339,6 +345,7 @@ impl NetworkManager {
}
}
#[instrument(level = "trace", skip(self), ret)]
pub fn check_client_whitelist(&self, client: DHTKey) -> bool {
let mut inner = self.inner.lock();
@@ -351,6 +358,7 @@ impl NetworkManager {
}
}
#[instrument(level = "trace", skip(self))]
pub fn purge_client_whitelist(&self) {
let timeout_ms = self.config.get().network.client_whitelist_timeout_ms;
let mut inner = self.inner.lock();
@@ -366,6 +374,15 @@ impl NetworkManager {
}
}
#[instrument(level = "debug", skip_all, err)]
async fn restart_net(&self, net: Network) -> Result<(), String> {
net.shutdown().await;
self.send_network_update();
net.startup().await?;
self.send_network_update();
Ok(())
}
pub async fn tick(&self) -> Result<(), String> {
let (routing_table, net, receipt_manager) = {
let inner = self.inner.lock();
@@ -380,10 +397,7 @@ impl NetworkManager {
// If the network needs to be reset, do it
// if things can't restart, then we fail out of the attachment manager
if net.needs_restart() {
net.shutdown().await;
self.send_network_update();
net.startup().await?;
self.send_network_update();
self.restart_net(net.clone()).await?;
}
// Run the rolling transfers task
@@ -448,6 +462,7 @@ impl NetworkManager {
}
// Generates a multi-shot/normal receipt
#[instrument(level = "trace", skip(self, extra_data, callback), err)]
pub fn generate_receipt<D: AsRef<[u8]>>(
&self,
expiration_us: u64,
@@ -473,6 +488,7 @@ impl NetworkManager {
}
// Generates a single-shot/normal receipt
#[instrument(level = "trace", skip(self, extra_data), err)]
pub fn generate_single_shot_receipt<D: AsRef<[u8]>>(
&self,
expiration_us: u64,
@@ -498,6 +514,7 @@ impl NetworkManager {
}
// Process a received out-of-band receipt
#[instrument(level = "trace", skip(self, receipt_data), err)]
pub async fn handle_out_of_band_receipt<R: AsRef<[u8]>>(
&self,
receipt_data: R,
@@ -511,6 +528,7 @@ impl NetworkManager {
}
// Process a received in-band receipt
#[instrument(level = "trace", skip(self, receipt_data), err)]
pub async fn handle_in_band_receipt<R: AsRef<[u8]>>(
&self,
receipt_data: R,
@@ -527,6 +545,7 @@ impl NetworkManager {
}
// Process a received signal
#[instrument(level = "trace", skip(self), err)]
pub async fn handle_signal(&self, signal_info: SignalInfo) -> Result<(), String> {
match signal_info {
SignalInfo::ReverseConnect { receipt, peer_info } => {
@@ -588,6 +607,7 @@ impl NetworkManager {
}
// Builds an envelope for sending over the network
#[instrument(level = "trace", skip(self, body), err)]
fn build_envelope<B: AsRef<[u8]>>(
&self,
dest_node_id: DHTKey,
@@ -614,6 +634,7 @@ impl NetworkManager {
// node_ref is the direct destination to which the envelope will be sent
// If 'node_id' is specified, it can be different than node_ref.node_id()
// which will cause the envelope to be relayed
#[instrument(level = "trace", skip(self, body), ret, err)]
pub async fn send_envelope<B: AsRef<[u8]>>(
&self,
node_ref: NodeRef,
@@ -665,6 +686,7 @@ impl NetworkManager {
}
// Called by the RPC handler when we want to issue an direct receipt
#[instrument(level = "trace", skip(self, rcpt_data), err)]
pub async fn send_out_of_band_receipt(
&self,
dial_info: DialInfo,
@@ -683,6 +705,7 @@ impl NetworkManager {
}
// Figure out how to reach a node
#[instrument(level = "trace", skip(self), ret, err)]
fn get_contact_method(&self, mut target_node_ref: NodeRef) -> Result<ContactMethod, String> {
let routing_table = self.routing_table();
@@ -802,6 +825,7 @@ impl NetworkManager {
// Send a reverse connection signal and wait for the return receipt over it
// Then send the data across the new connection
#[instrument(level = "trace", skip(self, data), err)]
pub async fn do_reverse_connect(
&self,
relay_nr: NodeRef,
@@ -872,6 +896,7 @@ impl NetworkManager {
// Send a hole punch signal and do a negotiating ping and wait for the return receipt
// Then send the data across the new connection
#[instrument(level = "trace", skip(self, data), err)]
pub async fn do_hole_punch(
&self,
relay_nr: NodeRef,
@@ -1036,6 +1061,7 @@ impl NetworkManager {
// Called when a packet potentially containing an RPC envelope is received by a low-level
// network protocol handler. Processes the envelope, authenticates and decrypts the RPC message
// and passes it to the RPC handler
#[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
async fn on_recv_envelope(
&self,
data: &[u8],
@@ -1175,6 +1201,7 @@ impl NetworkManager {
}
// Keep relays assigned and accessible
#[instrument(level = "trace", skip(self), err)]
async fn relay_management_task_routine(self, _last_ts: u64, cur_ts: u64) -> Result<(), String> {
// log_net!("--- network manager relay_management task");
@@ -1227,6 +1254,7 @@ impl NetworkManager {
}
// Compute transfer statistics for the low level network
#[instrument(level = "trace", skip(self), err)]
async fn rolling_transfers_task_routine(self, last_ts: u64, cur_ts: u64) -> Result<(), String> {
// log_net!("--- network manager rolling_transfers task");
{

9
veilid-core/src/network_manager/native/mod.rs
View File

@@ -267,6 +267,7 @@ impl Network {
// This creates a short-lived connection in the case of connection-oriented protocols
// for the purpose of sending this one message.
// This bypasses the connection table as it is not a 'node to node' connection.
#[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
pub async fn send_data_unbound_to_dial_info(
&self,
dial_info: DialInfo,
@@ -300,6 +301,7 @@ impl Network {
res
}
#[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
pub async fn send_data_to_existing_connection(
&self,
descriptor: ConnectionDescriptor,
@@ -357,6 +359,7 @@ impl Network {
}
// Send data directly to a dial info, possibly without knowing which node it is going to
#[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
pub async fn send_data_to_dial_info(
&self,
dial_info: DialInfo,
@@ -404,9 +407,8 @@ impl Network {
self.inner.lock().protocol_config
}
#[instrument(level = "debug", err, skip_all)]
pub async fn startup(&self) -> Result<(), String> {
trace!("startup network");
// initialize interfaces
let mut interfaces = NetworkInterfaces::new();
interfaces.refresh().await?;
@@ -492,10 +494,12 @@ impl Network {
self.inner.lock().network_started
}
#[instrument(level = "debug", skip_all)]
pub fn restart_network(&self) {
self.inner.lock().network_needs_restart = true;
}
#[instrument(level = "debug", skip_all)]
pub async fn shutdown(&self) {
info!("stopping network");
@@ -524,6 +528,7 @@ impl Network {
inner.network_class
}
#[instrument(level = "debug", skip_all)]
pub fn reset_network_class(&self) {
let mut inner = self.inner.lock();
inner.network_class = None;

37
veilid-core/src/network_manager/native/network_class_discovery.rs
View File

@@ -51,30 +51,30 @@ impl DiscoveryContext {
// Pick the best network class we have seen so far
pub fn set_detected_network_class(&self, network_class: NetworkClass) {
let mut inner = self.inner.lock();
log_net!( debug
"=== set_detected_network_class {:?} {:?}: {:?} ===",
inner.protocol_type,
inner.address_type,
network_class
debug!(target: "net",
protocol_type=?inner.protocol_type,
address_type=?inner.address_type,
?network_class,
"set_detected_network_class"
);
inner.detected_network_class = Some(network_class);
}
pub fn set_detected_public_dial_info(&self, dial_info: DialInfo, class: DialInfoClass) {
let mut inner = self.inner.lock();
log_net!( debug
"=== set_detected_public_dial_info {:?} {:?}: {} {:?} ===",
inner.protocol_type,
inner.address_type,
dial_info,
class
debug!(target: "net",
protocol_type=?inner.protocol_type,
address_type=?inner.address_type,
?dial_info,
?class,
"set_detected_public_dial_info"
);
inner.detected_public_dial_info = Some(DetectedPublicDialInfo { dial_info, class });
}
// Ask for a public address check from a particular noderef
// This is done over the normal port using RPC
#[instrument(level = "trace", skip(self), ret)]
async fn request_public_address(&self, node_ref: NodeRef) -> Option<SocketAddress> {
let rpc = self.routing_table.rpc_processor();
rpc.rpc_call_status(node_ref.clone())
@@ -93,6 +93,7 @@ impl DiscoveryContext {
// find fast peers with a particular address type, and ask them to tell us what our external address is
// This is done over the normal port using RPC
#[instrument(level = "trace", skip(self), ret)]
async fn discover_external_address(
&self,
protocol_type: ProtocolType,
@@ -122,6 +123,7 @@ impl DiscoveryContext {
}
// This pulls the already-detected local interface dial info from the routing table
#[instrument(level = "trace", skip(self), ret)]
fn get_local_addresses(
&self,
protocol_type: ProtocolType,
@@ -143,6 +145,7 @@ impl DiscoveryContext {
.collect()
}
#[instrument(level = "trace", skip(self), ret)]
async fn validate_dial_info(
&self,
node_ref: NodeRef,
@@ -165,6 +168,7 @@ impl DiscoveryContext {
.unwrap_or(false)
}
#[instrument(level = "trace", skip(self), ret)]
async fn try_port_mapping(&self) -> Option<DialInfo> {
//xxx
None
@@ -189,6 +193,7 @@ impl DiscoveryContext {
///////
// Per-protocol discovery routines
#[instrument(level = "trace", skip(self))]
pub fn protocol_begin(&self, protocol_type: ProtocolType, address_type: AddressType) {
// Get our interface addresses
let intf_addrs = self.get_local_addresses(protocol_type, address_type);
@@ -203,6 +208,7 @@ impl DiscoveryContext {
}
// Get our first node's view of our external IP address via normal RPC
#[instrument(level = "trace", skip(self), ret)]
pub async fn protocol_get_external_address_1(&self) -> bool {
let (protocol_type, address_type) = {
let inner = self.inner.lock();
@@ -234,6 +240,7 @@ impl DiscoveryContext {
}
// If we know we are not behind NAT, check our firewall status
#[instrument(level = "trace", skip(self), err)]
pub async fn protocol_process_no_nat(&self) -> Result<(), String> {
let (node_1, external_1_dial_info) = {
let inner = self.inner.lock();
@@ -264,6 +271,7 @@ impl DiscoveryContext {
}
// If we know we are behind NAT check what kind
#[instrument(level = "trace", skip(self), ret, err)]
pub async fn protocol_process_nat(&self) -> Result<bool, String> {
let (node_1, external_1_dial_info, external_1_address, protocol_type, address_type) = {
let inner = self.inner.lock();
@@ -353,6 +361,7 @@ impl DiscoveryContext {
}
impl Network {
#[instrument(level = "trace", skip(self, context), err)]
pub async fn update_ipv4_protocol_dialinfo(
&self,
context: &DiscoveryContext,
@@ -414,6 +423,7 @@ impl Network {
Ok(())
}
#[instrument(level = "trace", skip(self, context), err)]
pub async fn update_ipv6_protocol_dialinfo(
&self,
context: &DiscoveryContext,
@@ -454,9 +464,8 @@ impl Network {
Ok(())
}
#[instrument(level = "trace", skip(self), err)]
pub async fn update_network_class_task_routine(self, _l: u64, _t: u64) -> Result<(), String> {
log_net!("--- updating network class");
// Ensure we aren't trying to update this without clearing it first
let old_network_class = self.inner.lock().network_class;
assert_eq!(old_network_class, None);

3
veilid-core/src/network_manager/wasm/mod.rs
View File

@@ -51,6 +51,7 @@ impl Network {
/////////////////////////////////////////////////////////////////
#[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
pub async fn send_data_unbound_to_dial_info(
&self,
dial_info: DialInfo,
@@ -79,6 +80,7 @@ impl Network {
res
}
#[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
pub async fn send_data_to_existing_connection(
&self,
descriptor: ConnectionDescriptor,
@@ -115,6 +117,7 @@ impl Network {
}
}
#[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
pub async fn send_data_to_dial_info(
&self,
dial_info: DialInfo,

1
veilid-core/src/receipt_manager.rs
View File

@@ -234,6 +234,7 @@ impl ReceiptManager {
}
}
#[instrument(level = "trace", skip(self))]
pub async fn timeout_task_routine(self, now: u64) {
// Go through all receipts and build a list of expired nonces
let mut new_next_oldest_ts: Option<u64> = None;

17
veilid-core/src/routing_table/mod.rs
View File

@@ -730,6 +730,7 @@ impl RoutingTable {
best_inbound_relay.map(|(k, e)| NodeRef::new(self.clone(), *k, e, None))
}
#[instrument(level = "trace", skip(self), ret, err)]
pub fn register_find_node_answer(&self, fna: FindNodeAnswer) -> Result<Vec<NodeRef>, String> {
let node_id = self.node_id();
@@ -755,6 +756,7 @@ impl RoutingTable {
Ok(out)
}
#[instrument(level = "trace", skip(self), ret, err)]
pub async fn find_node(
&self,
node_ref: NodeRef,
@@ -773,26 +775,24 @@ impl RoutingTable {
.await
.map_err(map_to_string)
.map_err(logthru_rtab!())?;
log_rtab!(
"find_self for at {:?} answered in {}ms",
&node_ref,
timestamp_to_secs(res.latency) * 1000.0f64
);
// register nodes we'd found
self.register_find_node_answer(res)
}
#[instrument(level = "trace", skip(self), ret, err)]
pub async fn find_self(&self, node_ref: NodeRef) -> Result<Vec<NodeRef>, String> {
let node_id = self.node_id();
self.find_node(node_ref, node_id).await
}
#[instrument(level = "trace", skip(self), ret, err)]
pub async fn find_target(&self, node_ref: NodeRef) -> Result<Vec<NodeRef>, String> {
let node_id = node_ref.node_id();
self.find_node(node_ref, node_id).await
}
#[instrument(level = "trace", skip(self))]
pub async fn reverse_find_node(&self, node_ref: NodeRef, wide: bool) {
// Ask bootstrap node to 'find' our own node so we can get some more nodes near ourselves
// and then contact those nodes to inform -them- that we exist
@@ -827,6 +827,7 @@ impl RoutingTable {
}
// Bootstrap lookup process
#[instrument(level = "trace", skip(self), ret, err)]
async fn resolve_bootstrap(
&self,
bootstrap: Vec<String>,
@@ -990,6 +991,7 @@ impl RoutingTable {
Ok(bsmap)
}
#[instrument(level = "trace", skip(self), err)]
async fn bootstrap_task_routine(self) -> Result<(), String> {
let (bootstrap, bootstrap_nodes) = {
let c = self.config.get();
@@ -1092,9 +1094,8 @@ impl RoutingTable {
// Ask our remaining peers to give us more peers before we go
// back to the bootstrap servers to keep us from bothering them too much
#[instrument(level = "trace", skip(self), err)]
async fn peer_minimum_refresh_task_routine(self) -> Result<(), String> {
// log_rtab!("--- peer_minimum_refresh task");
// get list of all peers we know about, even the unreliable ones, and ask them to find nodes close to our node too
let noderefs = {
let mut inner = self.inner.lock();
@@ -1125,6 +1126,7 @@ impl RoutingTable {
// Ping each node in the routing table if they need to be pinged
// to determine their reliability
#[instrument(level = "trace", skip(self), err)]
async fn ping_validator_task_routine(self, _last_ts: u64, cur_ts: u64) -> Result<(), String> {
// log_rtab!("--- ping_validator task");
@@ -1149,6 +1151,7 @@ impl RoutingTable {
}
// Compute transfer statistics to determine how 'fast' a node is
#[instrument(level = "trace", skip(self), err)]
async fn rolling_transfers_task_routine(self, last_ts: u64, cur_ts: u64) -> Result<(), String> {
// log_rtab!("--- rolling_transfers task");
let inner = &mut *self.inner.lock();

20
veilid-core/src/veilid_api/mod.rs
View File

@@ -1742,6 +1742,7 @@ pub struct VeilidAPI {
}
impl VeilidAPI {
#[instrument(skip_all)]
pub(crate) fn new(context: VeilidCoreContext) -> Self {
Self {
inner: Arc::new(Mutex::new(VeilidAPIInner {
@@ -1750,6 +1751,7 @@ impl VeilidAPI {
}
}
#[instrument(skip_all)]
pub async fn shutdown(self) {
let context = { self.inner.lock().context.take() };
if let Some(context) = context {
@@ -1840,6 +1842,7 @@ impl VeilidAPI {
// get network connectedness
// connect to the network
#[instrument(level = "debug", err, skip_all)]
pub async fn attach(&self) -> Result<(), VeilidAPIError> {
let attachment_manager = self.attachment_manager()?;
attachment_manager
@@ -1849,6 +1852,7 @@ impl VeilidAPI {
}
// disconnect from the network
#[instrument(level = "debug", err, skip_all)]
pub async fn detach(&self) -> Result<(), VeilidAPIError> {
let attachment_manager = self.attachment_manager()?;
attachment_manager
@@ -1858,6 +1862,7 @@ impl VeilidAPI {
}
// Change api logging level if it is enabled
#[instrument(skip(self))]
pub async fn change_api_log_level(&self, log_level: VeilidConfigLogLevel) {
ApiTracingLayer::change_api_log_level(log_level.to_veilid_log_level());
}
@@ -1865,6 +1870,7 @@ impl VeilidAPI {
////////////////////////////////////////////////////////////////
// Direct Node Access (pretty much for testing only)
#[instrument(level = "debug", err, skip(self))]
pub async fn status(&self, node_id: NodeId) -> Result<StatusAnswer, VeilidAPIError> {
let rpc = self.rpc_processor()?;
let routing_table = rpc.routing_table();
@@ -1879,6 +1885,7 @@ impl VeilidAPI {
Ok(status_answer)
}
#[instrument(level = "debug", err, skip(self))]
pub async fn validate_dial_info(
&self,
node_id: NodeId,
@@ -1896,6 +1903,7 @@ impl VeilidAPI {
.map_err(map_rpc_error!())
}
#[instrument(level = "debug", err, skip(self))]
pub async fn search_dht(&self, node_id: NodeId) -> Result<PeerInfo, VeilidAPIError> {
let rpc_processor = self.rpc_processor()?;
let config = self.config()?;
@@ -1923,6 +1931,7 @@ impl VeilidAPI {
}
}
#[instrument(level = "debug", err, skip(self))]
pub async fn search_dht_multi(&self, node_id: NodeId) -> Result<Vec<PeerInfo>, VeilidAPIError> {
let rpc_processor = self.rpc_processor()?;
let config = self.config()?;
@@ -1948,6 +1957,7 @@ impl VeilidAPI {
////////////////////////////////////////////////////////////////
// Safety / Private Route Handling
#[instrument(level = "debug", err, skip(self))]
pub async fn new_safety_route_spec(
&self,
_hops: u8,
@@ -1955,6 +1965,7 @@ impl VeilidAPI {
panic!("unimplemented");
}
#[instrument(level = "debug", err, skip(self))]
pub async fn new_private_route_spec(
&self,
_hops: u8,
@@ -1968,6 +1979,7 @@ impl VeilidAPI {
// Safety route specified here is for _this_ node's anonymity as a sender, used via the 'route' operation
// Private route specified here is for _this_ node's anonymity as a receiver, passed out via the 'respond_to' field for replies
#[instrument(skip(self))]
pub async fn safe_private(
&self,
safety_route_spec: SafetyRouteSpec,
@@ -1980,6 +1992,7 @@ impl VeilidAPI {
.await
}
#[instrument(level = "debug", skip(self))]
pub async fn safe_public(&self, safety_route_spec: SafetyRouteSpec) -> RoutingContext {
self.routing_context(RoutingContextOptions {
safety_route_spec: Some(safety_route_spec),
@@ -1988,6 +2001,7 @@ impl VeilidAPI {
.await
}
#[instrument(level = "debug", skip(self))]
pub async fn unsafe_private(&self, private_route_spec: PrivateRouteSpec) -> RoutingContext {
self.routing_context(RoutingContextOptions {
safety_route_spec: None,
@@ -1996,6 +2010,7 @@ impl VeilidAPI {
.await
}
#[instrument(level = "debug", skip(self))]
pub async fn unsafe_public(&self) -> RoutingContext {
self.routing_context(RoutingContextOptions {
safety_route_spec: None,
@@ -2003,6 +2018,8 @@ impl VeilidAPI {
})
.await
}
#[instrument(level = "debug", skip(self))]
pub async fn routing_context(&self, options: RoutingContextOptions) -> RoutingContext {
RoutingContext::new(self.clone(), options)
}
@@ -2010,6 +2027,7 @@ impl VeilidAPI {
////////////////////////////////////////////////////////////////
// Tunnel Building
#[instrument(level = "debug", err, skip(self))]
pub async fn start_tunnel(
&self,
_endpoint_mode: TunnelMode,
@@ -2018,6 +2036,7 @@ impl VeilidAPI {
panic!("unimplemented");
}
#[instrument(level = "debug", err, skip(self))]
pub async fn complete_tunnel(
&self,
_endpoint_mode: TunnelMode,
@@ -2027,6 +2046,7 @@ impl VeilidAPI {
panic!("unimplemented");
}
#[instrument(level = "debug", err, skip(self))]
pub async fn cancel_tunnel(&self, _tunnel_id: TunnelId) -> Result<bool, VeilidAPIError> {
panic!("unimplemented");
}

34
veilid-core/src/veilid_api/serialize_helpers.rs
View File

@@ -1,24 +1,40 @@
use super::*;
use core::fmt::Debug;
pub fn deserialize_json<'a, T: de::Deserialize<'a>>(
#[instrument(level = "trace", ret, err)]
pub fn deserialize_json<'a, T: de::Deserialize<'a> + Debug>(
arg: &'a str,
) -> Result<T, super::VeilidAPIError> {
) -> Result<T, VeilidAPIError> {
serde_json::from_str(arg).map_err(|e| VeilidAPIError::ParseError {
message: e.to_string(),
value: String::new(),
value: format!(
"deserialize_json:\n---\n{}\n---\n to type {}",
arg,
std::any::type_name::<T>()
),
})
}
pub fn deserialize_opt_json<T: de::DeserializeOwned>(
#[instrument(level = "trace", ret, err)]
pub fn deserialize_opt_json<T: de::DeserializeOwned + Debug>(
arg: Option<String>,
) -> Result<T, VeilidAPIError> {
let arg = arg.ok_or_else(|| VeilidAPIError::ParseError {
let arg = arg.as_ref().ok_or_else(|| VeilidAPIError::ParseError {
message: "invalid null string".to_owned(),
value: String::new(),
value: format!(
"deserialize_json_opt: null to type {}",
std::any::type_name::<T>()
),
})?;
deserialize_json(&arg)
deserialize_json(arg)
}
pub fn serialize_json<T: Serialize>(val: T) -> String {
serde_json::to_string(&val).expect("failed to serialize json value")
#[instrument(level = "trace", ret)]
pub fn serialize_json<T: Serialize + Debug>(val: T) -> String {
match serde_json::to_string(&val) {
Ok(v) => v,
Err(e) => {
panic!("failed to serialize json value: {}\nval={:?}", e, val);
}
}
}

9
veilid-core/src/veilid_config.rs
View File

@@ -237,6 +237,15 @@ pub struct VeilidConfig {
inner: Arc<RwLock<VeilidConfigInner>>,
}
impl fmt::Debug for VeilidConfig {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let inner = self.inner.read();
f.debug_struct("VeilidConfig")
.field("inner", &*inner)
.finish()
}
}
impl Default for VeilidConfig {
fn default() -> Self {
Self::new()