IntenseWebs/veilid
3
0
Fork 0
mirror of https://gitlab.com/veilid/veilid.git synced 2024-11-22 00:47:28 -06:00
Code Issues Packages Projects Releases Wiki Activity

Assorted comment typo and formatting fixes

Browse Source
This commit is contained in:
Sashanoraa 2024-05-01 20:37:06 -04:00
parent 439d2641f1
commit 5da287fae4
17 changed files with 159 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -120,7 +120,7 @@ impl AttachmentManager {
} }
/// Update attachment and network readiness state /// Update attachment and network readiness state
/// and possibly send a VeilidUpdate::Attachment /// and possibly send a VeilidUpdate::Attachment.
fn update_attachment(&self) { fn update_attachment(&self) {
// update the routing table health // update the routing table health
let routing_table = self.network_manager().routing_table(); let routing_table = self.network_manager().routing_table();

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

@ -8,9 +8,9 @@ use crate::*;
pub type UpdateCallback = Arc<dyn Fn(VeilidUpdate) + Send + Sync>; pub type UpdateCallback = Arc<dyn Fn(VeilidUpdate) + Send + Sync>;
/// Internal services startup mechanism /// Internal services startup mechanism.
/// Ensures that everything is started up, and shut down in the right order /// Ensures that everything is started up, and shut down in the right order
/// and provides an atomic state for if the system is properly operational /// and provides an atomic state for if the system is properly operational.
struct ServicesContext { struct ServicesContext {
pub config: VeilidConfig, pub config: VeilidConfig,
pub update_callback: UpdateCallback, pub update_callback: UpdateCallback,
@ -289,12 +289,12 @@ lazy_static::lazy_static! {
/// Initialize a Veilid node. /// Initialize a Veilid node.
/// ///
/// Must be called only once at the start of an application /// Must be called only once at the start of an application.
/// ///
/// * `update_callback` - called when internal state of the Veilid node changes, for example, when app-level messages are received, when private routes die and need to be reallocated, or when routing table states change /// * `update_callback` - called when internal state of the Veilid node changes, for example, when app-level messages are received, when private routes die and need to be reallocated, or when routing table states change.
/// * `config_callback` - called at startup to supply a configuration object directly to Veilid /// * `config_callback` - called at startup to supply a configuration object directly to Veilid.
/// ///
/// Returns a [VeilidAPI] object that can be used to operate the node /// Returns a [VeilidAPI] object that can be used to operate the node.
#[instrument(err, skip_all)] #[instrument(err, skip_all)]
pub async fn api_startup( pub async fn api_startup(
update_callback: UpdateCallback, update_callback: UpdateCallback,
@ -318,14 +318,14 @@ pub async fn api_startup(
Ok(veilid_api) Ok(veilid_api)
} }
/// Initialize a Veilid node, with the configuration in JSON format /// Initialize a Veilid node, with the configuration in JSON format.
/// ///
/// Must be called only once at the start of an application /// Must be called only once at the start of an application.
/// ///
/// * `update_callback` - called when internal state of the Veilid node changes, for example, when app-level messages are received, when private routes die and need to be reallocated, or when routing table states change /// * `update_callback` - called when internal state of the Veilid node changes, for example, when app-level messages are received, when private routes die and need to be reallocated, or when routing table states change.
/// * `config_json` - called at startup to supply a JSON configuration object /// * `config_json` - called at startup to supply a JSON configuration object.
/// ///
/// Returns a [VeilidAPI] object that can be used to operate the node /// Returns a [VeilidAPI] object that can be used to operate the node.
#[instrument(err, skip_all)] #[instrument(err, skip_all)]
pub async fn api_startup_json( pub async fn api_startup_json(
update_callback: UpdateCallback, update_callback: UpdateCallback,
@ -348,14 +348,14 @@ pub async fn api_startup_json(
Ok(veilid_api) Ok(veilid_api)
} }
/// Initialize a Veilid node, with the configuration object /// Initialize a Veilid node, with the configuration object.
/// ///
/// Must be called only once at the start of an application /// Must be called only once at the start of an application.
/// ///
/// * `update_callback` - called when internal state of the Veilid node changes, for example, when app-level messages are received, when private routes die and need to be reallocated, or when routing table states change /// * `update_callback` - called when internal state of the Veilid node changes, for example, when app-level messages are received, when private routes die and need to be reallocated, or when routing table states change.
/// * `config` - called at startup to supply a configuration object /// * `config` - called at startup to supply a configuration object.
/// ///
/// Returns a [VeilidAPI] object that can be used to operate the node /// Returns a [VeilidAPI] object that can be used to operate the node.
#[instrument(err, skip_all)] #[instrument(err, skip_all)]
pub async fn api_startup_config( pub async fn api_startup_config(
update_callback: UpdateCallback, update_callback: UpdateCallback,

12
veilid-core/src/lib.rs
View File

@ -14,12 +14,12 @@
//! //!
//! The default `veilid-core` configurations are: //! The default `veilid-core` configurations are:
//! //!
//! * `default` - Uses `tokio` as the async runtime //! * `default` - Uses `tokio` as the async runtime.
//! //!
//! If you use `--no-default-features`, you can switch to other runtimes: //! If you use `--no-default-features`, you can switch to other runtimes:
//! //!
//! * `default-async-std` - Uses `async-std` as the async runtime //! * `default-async-std` - Uses `async-std` as the async runtime.
//! * `default-wasm` - When building for the `wasm32` architecture, use this to enable `wasm-bindgen-futures` as the async runtime //! * `default-wasm` - When building for the `wasm32` architecture, use this to enable `wasm-bindgen-futures` as the async runtime.
//! //!
#![deny(clippy::all)] #![deny(clippy::all)]
@ -67,7 +67,7 @@ pub use self::veilid_api::*;
pub use self::veilid_config::*; pub use self::veilid_config::*;
pub use veilid_tools as tools; pub use veilid_tools as tools;
/// The on-the-wire serialization format for Veilid RPC /// The on-the-wire serialization format for Veilid RPC.
pub mod veilid_capnp { pub mod veilid_capnp {
include!("../proto/veilid_capnp.rs"); include!("../proto/veilid_capnp.rs");
} }
@ -75,12 +75,12 @@ pub mod veilid_capnp {
#[doc(hidden)] #[doc(hidden)]
pub mod tests; pub mod tests;
/// Return the cargo package version of veilid-core in string format /// Return the cargo package version of veilid-core in string format.
pub fn veilid_version_string() -> String { pub fn veilid_version_string() -> String {
env!("CARGO_PKG_VERSION").to_owned() env!("CARGO_PKG_VERSION").to_owned()
} }
/// Return the cargo package version of veilid-core in tuple format /// Return the cargo package version of veilid-core in tuple format.
pub fn veilid_version() -> (u32, u32, u32) { pub fn veilid_version() -> (u32, u32, u32) {
( (
u32::from_str(env!("CARGO_PKG_VERSION_MAJOR")).unwrap(), u32::from_str(env!("CARGO_PKG_VERSION_MAJOR")).unwrap(),

6
veilid-core/src/table_store/mod.rs
View File

@ -26,8 +26,8 @@ struct TableStoreInner {
crypto: Option<Crypto>, crypto: Option<Crypto>,
} }
/// Veilid Table Storage /// Veilid Table Storage.
/// Database for storing key value pairs persistently and securely across runs /// Database for storing key value pairs persistently and securely across runs.
#[derive(Clone)] #[derive(Clone)]
pub struct TableStore { pub struct TableStore {
config: VeilidConfig, config: VeilidConfig,
@ -444,7 +444,7 @@ impl TableStore {
} }
/// Get or create a TableDB database table. If the column count is greater than an /// Get or create a TableDB database table. If the column count is greater than an
/// existing TableDB's column count, the database will be upgraded to add the missing columns /// existing TableDB's column count, the database will be upgraded to add the missing columns.
pub async fn open(&self, name: &str, column_count: u32) -> VeilidAPIResult<TableDB> { pub async fn open(&self, name: &str, column_count: u32) -> VeilidAPIResult<TableDB> {
let _async_guard = self.async_lock.lock().await; let _async_guard = self.async_lock.lock().await;

14
veilid-core/src/table_store/table_db.rs
View File

@ -88,19 +88,19 @@ impl TableDB {
Arc::downgrade(&self.unlocked_inner) Arc::downgrade(&self.unlocked_inner)
} }
/// Get the total number of columns in the TableDB /// Get the total number of columns in the TableDB.
/// Not the number of columns that were opened, rather the total number that could be opened /// Not the number of columns that were opened, rather the total number that could be opened.
pub fn get_column_count(&self) -> VeilidAPIResult<u32> { pub fn get_column_count(&self) -> VeilidAPIResult<u32> {
let db = &self.unlocked_inner.database; let db = &self.unlocked_inner.database;
db.num_columns().map_err(VeilidAPIError::from) db.num_columns().map_err(VeilidAPIError::from)
} }
/// Encrypt buffer using encrypt key and prepend nonce to output /// Encrypt buffer using encrypt key and prepend nonce to output.
/// Keyed nonces are unique because keys must be unique /// Keyed nonces are unique because keys must be unique.
/// Normally they must be sequential or random, but the critical /// Normally they must be sequential or random, but the critical.
/// requirement is that they are different for each encryption /// requirement is that they are different for each encryption
/// but if the contents are guaranteed to be unique, then a nonce /// but if the contents are guaranteed to be unique, then a nonce
/// can be generated from the hash of the contents and the encryption key itself /// can be generated from the hash of the contents and the encryption key itself.
fn maybe_encrypt(&self, data: &[u8], keyed_nonce: bool) -> Vec<u8> { fn maybe_encrypt(&self, data: &[u8], keyed_nonce: bool) -> Vec<u8> {
let data = compress_prepend_size(data); let data = compress_prepend_size(data);
if let Some(ei) = &self.unlocked_inner.encrypt_info { if let Some(ei) = &self.unlocked_inner.encrypt_info {
@ -155,7 +155,7 @@ impl TableDB {
} }
} }
/// Get the list of keys in a column of the TableDAB /// Get the list of keys in a column of the TableDB
pub async fn get_keys(&self, col: u32) -> VeilidAPIResult<Vec<Vec<u8>>> { pub async fn get_keys(&self, col: u32) -> VeilidAPIResult<Vec<Vec<u8>>> {
if col >= self.opened_column_count { if col >= self.opened_column_count {
apibail_generic!(format!( apibail_generic!(format!(

64
veilid-core/src/veilid_api/api.rs
View File

@ -20,19 +20,19 @@ impl Drop for VeilidAPIInner {
} }
} }
/// The primary developer entrypoint into `veilid-core` functionality /// The primary developer entrypoint into `veilid-core` functionality.
/// ///
/// From [VeilidAPI] one can access: /// From [VeilidAPI] one can access:
/// ///
/// * [VeilidConfig] - The Veilid configuration specified at startup time /// * [VeilidConfig] - The Veilid configuration specified at startup time.
/// * [Crypto] - The available set of cryptosystems provided by Veilid /// * [Crypto] - The available set of cryptosystems provided by Veilid.
/// * [TableStore] - The Veilid table-based encrypted persistent key-value store /// * [TableStore] - The Veilid table-based encrypted persistent key-value store.
/// * [ProtectedStore] - The Veilid abstract of the device's low-level 'protected secret storage' /// * [ProtectedStore] - The Veilid abstract of the device's low-level 'protected secret storage'.
/// * [VeilidState] - The current state of the Veilid node this API accesses /// * [VeilidState] - The current state of the Veilid node this API accesses.
/// * [RoutingContext] - Communication methods between Veilid nodes and private routes /// * [RoutingContext] - Communication methods between Veilid nodes and private routes.
/// * Attach and detach from the network /// * Attach and detach from the network.
/// * Create and import private routes /// * Create and import private routes.
/// * Reply to `AppCall` RPCs /// * Reply to `AppCall` RPCs.
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct VeilidAPI { pub struct VeilidAPI {
inner: Arc<Mutex<VeilidAPIInner>>, inner: Arc<Mutex<VeilidAPIInner>>,
@ -50,7 +50,7 @@ impl VeilidAPI {
} }
} }
/// Shut down Veilid and terminate the API /// Shut down Veilid and terminate the API.
#[instrument(target = "veilid_api", level = "debug", skip_all)] #[instrument(target = "veilid_api", level = "debug", skip_all)]
pub async fn shutdown(self) { pub async fn shutdown(self) {
event!(target: "veilid_api", Level::DEBUG, event!(target: "veilid_api", Level::DEBUG,
@ -61,7 +61,7 @@ impl VeilidAPI {
} }
} }
/// Check to see if Veilid is already shut down /// Check to see if Veilid is already shut down.
pub fn is_shutdown(&self) -> bool { pub fn is_shutdown(&self) -> bool {
self.inner.lock().context.is_none() self.inner.lock().context.is_none()
} }
@ -69,7 +69,7 @@ impl VeilidAPI {
//////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////
// Public Accessors // Public Accessors
/// Access the configuration that Veilid was initialized with /// Access the configuration that Veilid was initialized with.
pub fn config(&self) -> VeilidAPIResult<VeilidConfig> { pub fn config(&self) -> VeilidAPIResult<VeilidConfig> {
let inner = self.inner.lock(); let inner = self.inner.lock();
if let Some(context) = &inner.context { if let Some(context) = &inner.context {
@ -78,7 +78,7 @@ impl VeilidAPI {
Err(VeilidAPIError::NotInitialized) Err(VeilidAPIError::NotInitialized)
} }
/// Get the cryptosystem manager /// Get the cryptosystem manager.
pub fn crypto(&self) -> VeilidAPIResult<Crypto> { pub fn crypto(&self) -> VeilidAPIResult<Crypto> {
let inner = self.inner.lock(); let inner = self.inner.lock();
if let Some(context) = &inner.context { if let Some(context) = &inner.context {
@ -87,7 +87,7 @@ impl VeilidAPI {
Err(VeilidAPIError::NotInitialized) Err(VeilidAPIError::NotInitialized)
} }
/// Get the TableStore manager /// Get the TableStore manager.
pub fn table_store(&self) -> VeilidAPIResult<TableStore> { pub fn table_store(&self) -> VeilidAPIResult<TableStore> {
let inner = self.inner.lock(); let inner = self.inner.lock();
if let Some(context) = &inner.context { if let Some(context) = &inner.context {
@ -96,7 +96,7 @@ impl VeilidAPI {
Err(VeilidAPIError::not_initialized()) Err(VeilidAPIError::not_initialized())
} }
/// Get the ProtectedStore manager /// Get the ProtectedStore manager.
pub fn protected_store(&self) -> VeilidAPIResult<ProtectedStore> { pub fn protected_store(&self) -> VeilidAPIResult<ProtectedStore> {
let inner = self.inner.lock(); let inner = self.inner.lock();
if let Some(context) = &inner.context { if let Some(context) = &inner.context {
@ -154,7 +154,7 @@ impl VeilidAPI {
//////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////
// Attach/Detach // Attach/Detach
/// Get a full copy of the current state of Veilid /// Get a full copy of the current state of Veilid.
pub async fn get_state(&self) -> VeilidAPIResult<VeilidState> { pub async fn get_state(&self) -> VeilidAPIResult<VeilidState> {
let attachment_manager = self.attachment_manager()?; let attachment_manager = self.attachment_manager()?;
let network_manager = attachment_manager.network_manager(); let network_manager = attachment_manager.network_manager();
@ -171,7 +171,7 @@ impl VeilidAPI {
}) })
} }
/// Connect to the network /// Connect to the network.
#[instrument(target = "veilid_api", level = "debug", skip_all, ret, err)] #[instrument(target = "veilid_api", level = "debug", skip_all, ret, err)]
pub async fn attach(&self) -> VeilidAPIResult<()> { pub async fn attach(&self) -> VeilidAPIResult<()> {
event!(target: "veilid_api", Level::DEBUG, event!(target: "veilid_api", Level::DEBUG,
@ -184,7 +184,7 @@ impl VeilidAPI {
Ok(()) Ok(())
} }
/// Disconnect from the network /// Disconnect from the network.
#[instrument(target = "veilid_api", level = "debug", skip_all, ret, err)] #[instrument(target = "veilid_api", level = "debug", skip_all, ret, err)]
pub async fn detach(&self) -> VeilidAPIResult<()> { pub async fn detach(&self) -> VeilidAPIResult<()> {
event!(target: "veilid_api", Level::DEBUG, event!(target: "veilid_api", Level::DEBUG,
@ -209,13 +209,13 @@ impl VeilidAPI {
RoutingContext::try_new(self.clone()) RoutingContext::try_new(self.clone())
} }
/// Parse a string into a target object that can be used in a [RoutingContext] /// Parse a string into a target object that can be used in a [RoutingContext].
/// ///
/// Strings are in base64url format and can either be a remote route id or a node id. /// Strings are in base64url format and can either be a remote route id or a node id.
/// Strings may have a [CryptoKind] [FourCC] prefix separated by a colon, such as: /// Strings may have a [CryptoKind] [FourCC] prefix separated by a colon, such as:
/// `VLD0:XmnGyJrjMJBRC5ayJZRPXWTBspdX36-pbLb98H3UMeE` but if the prefix is left off /// `VLD0:XmnGyJrjMJBRC5ayJZRPXWTBspdX36-pbLb98H3UMeE` but if the prefix is left off
/// `XmnGyJrjMJBRC5ayJZRPXWTBspdX36-pbLb98H3UMeE` will be parsed with the 'best' cryptosystem /// `XmnGyJrjMJBRC5ayJZRPXWTBspdX36-pbLb98H3UMeE` will be parsed with the 'best' cryptosystem
/// available (at the time of this writing this is `VLD0`) /// available (at the time of this writing this is `VLD0`).
#[instrument(target = "veilid_api", level = "debug", skip(self), fields(s=s.to_string()), ret, err)] #[instrument(target = "veilid_api", level = "debug", skip(self), fields(s=s.to_string()), ret, err)]
pub fn parse_as_target<S: ToString>(&self, s: S) -> VeilidAPIResult<Target> { pub fn parse_as_target<S: ToString>(&self, s: S) -> VeilidAPIResult<Target> {
let s = s.to_string(); let s = s.to_string();
@ -245,10 +245,10 @@ impl VeilidAPI {
//////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////
// Private route allocation // Private route allocation
/// Allocate a new private route set with default cryptography and network options /// Allocate a new private route set with default cryptography and network options.
/// Default settings are for Stability::Reliable and Sequencing::EnsureOrdered /// Default settings are for [Stability::Reliable] and [Sequencing::EnsureOrdered].
/// Returns a route id and a publishable 'blob' with the route encrypted with each crypto kind /// Returns a route id and a publishable 'blob' with the route encrypted with each crypto kind.
/// Those nodes importing the blob will have their choice of which crypto kind to use /// Those nodes importing the blob will have their choice of which crypto kind to use.
/// ///
/// Returns a route id and 'blob' that can be published over some means (DHT or otherwise) to be /// Returns a route id and 'blob' that can be published over some means (DHT or otherwise) to be
/// imported by another Veilid node. /// imported by another Veilid node.
@ -262,11 +262,11 @@ impl VeilidAPI {
.await .await
} }
/// Allocate a new private route and specify a specific cryptosystem, stability and sequencing preference /// Allocate a new private route and specify a specific cryptosystem, stability and sequencing preference.
/// Faster connections may be possible with Stability::LowLatency, and Sequencing::NoPreference at the /// Faster connections may be possible with [Stability::LowLatency], and [Sequencing::NoPreference] at the
/// expense of some loss of messages /// expense of some loss of messages.
/// Returns a route id and a publishable 'blob' with the route encrypted with each crypto kind /// Returns a route id and a publishable 'blob' with the route encrypted with each crypto kind.
/// Those nodes importing the blob will have their choice of which crypto kind to use /// Those nodes importing the blob will have their choice of which crypto kind to use.
/// ///
/// Returns a route id and 'blob' that can be published over some means (DHT or otherwise) to be /// Returns a route id and 'blob' that can be published over some means (DHT or otherwise) to be
/// imported by another Veilid node. /// imported by another Veilid node.
@ -332,7 +332,7 @@ impl VeilidAPI {
rss.import_remote_private_route_blob(blob) rss.import_remote_private_route_blob(blob)
} }
/// Release either a locally allocated or remotely imported private route /// Release either a locally allocated or remotely imported private route.
/// ///
/// This will deactivate the route and free its resources and it can no longer be sent to /// This will deactivate the route and free its resources and it can no longer be sent to
/// or received from. /// or received from.
@ -353,7 +353,7 @@ impl VeilidAPI {
/// Respond to an AppCall received over a [VeilidUpdate::AppCall]. /// Respond to an AppCall received over a [VeilidUpdate::AppCall].
/// ///
/// * `call_id` - specifies which call to reply to, and it comes from a [VeilidUpdate::AppCall], specifically the [VeilidAppCall::id()] value. /// * `call_id` - specifies which call to reply to, and it comes from a [VeilidUpdate::AppCall], specifically the [VeilidAppCall::id()] value.
/// * `message` - is an answer blob to be returned by the remote node's [RoutingContext::app_call()] function, and may be up to 32768 bytes /// * `message` - is an answer blob to be returned by the remote node's [RoutingContext::app_call()] function, and may be up to 32768 bytes.
#[instrument(target = "veilid_api", level = "debug", skip(self), ret, err)] #[instrument(target = "veilid_api", level = "debug", skip(self), ret, err)]
pub async fn app_call_reply( pub async fn app_call_reply(
&self, &self,

4
veilid-core/src/veilid_api/debug.rs
View File

@ -1924,7 +1924,7 @@ impl VeilidAPI {
} }
} }
/// Get the help text for 'internal debug' commands /// Get the help text for 'internal debug' commands.
pub async fn debug_help(&self, _args: String) -> VeilidAPIResult<String> { pub async fn debug_help(&self, _args: String) -> VeilidAPIResult<String> {
Ok(r#"buckets [dead|reliable] Ok(r#"buckets [dead|reliable]
dialinfo dialinfo
@ -2002,7 +2002,7 @@ record list <local|remote|opened|offline>
.to_owned()) .to_owned())
} }
/// Execute an 'internal debug command' /// Execute an 'internal debug command'.
pub async fn debug(&self, args: String) -> VeilidAPIResult<String> { pub async fn debug(&self, args: String) -> VeilidAPIResult<String> {
let res = { let res = {
let args = args.trim_start(); let args = args.trim_start();

8
veilid-core/src/veilid_api/json_api/mod.rs
View File

@ -14,10 +14,10 @@ pub use process::*;
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)] #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct Request { pub struct Request {
/// Operation Id (pairs with Response, or empty if unidirectional) /// Operation Id (pairs with Response, or empty if unidirectional).
#[serde(default)] #[serde(default)]
pub id: u32, pub id: u32,
/// The request operation variant /// The request operation variant.
#[serde(flatten)] #[serde(flatten)]
pub op: RequestOp, pub op: RequestOp,
} }
@ -31,10 +31,10 @@ pub enum RecvMessage {
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)] #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct Response { pub struct Response {
/// Operation Id (pairs with Request, or empty if unidirectional) /// Operation Id (pairs with Request, or empty if unidirectional).
#[serde(default)] #[serde(default)]
pub id: u32, pub id: u32,
/// The response operation variant /// The response operation variant.
#[serde(flatten)] #[serde(flatten)]
pub op: ResponseOp, pub op: ResponseOp,
} }

87
veilid-core/src/veilid_api/routing_context.rs
View File

@ -2,19 +2,19 @@ use super::*;
/////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////
/// Valid destinations for a message sent over a routing context /// Valid destinations for a message sent over a routing context.
#[derive(Clone, Debug, Eq, PartialEq, Hash, Copy, PartialOrd, Ord)] #[derive(Clone, Debug, Eq, PartialEq, Hash, Copy, PartialOrd, Ord)]
pub enum Target { pub enum Target {
/// Node by its public key /// Node by its public key.
NodeId(TypedKey), NodeId(TypedKey),
/// Remote private route by its id /// Remote private route by its id.
PrivateRoute(RouteId), PrivateRoute(RouteId),
} }
pub struct RoutingContextInner {} pub struct RoutingContextInner {}
pub struct RoutingContextUnlockedInner { pub struct RoutingContextUnlockedInner {
/// Safety routing requirements /// Safety routing requirements.
safety_selection: SafetySelection, safety_selection: SafetySelection,
} }
@ -26,7 +26,7 @@ pub struct RoutingContextUnlockedInner {
/// ///
#[derive(Clone)] #[derive(Clone)]
pub struct RoutingContext { pub struct RoutingContext {
/// Veilid API handle /// Veilid API handle.
api: VeilidAPI, api: VeilidAPI,
inner: Arc<Mutex<RoutingContextInner>>, inner: Arc<Mutex<RoutingContextInner>>,
unlocked_inner: Arc<RoutingContextUnlockedInner>, unlocked_inner: Arc<RoutingContextUnlockedInner>,
@ -69,7 +69,7 @@ impl RoutingContext {
/// ///
/// * Hop count default is dependent on config, but is set to 1 extra hop. /// * Hop count default is dependent on config, but is set to 1 extra hop.
/// * Stability default is to choose 'low latency' routes, preferring them over long-term reliability. /// * Stability default is to choose 'low latency' routes, preferring them over long-term reliability.
/// * Sequencing default is to prefer ordered before unordered message delivery /// * Sequencing default is to prefer ordered before unordered message delivery.
/// ///
/// To customize the safety selection in use, use [RoutingContext::with_safety()]. /// To customize the safety selection in use, use [RoutingContext::with_safety()].
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]
@ -88,7 +88,7 @@ impl RoutingContext {
})) }))
} }
/// Use a custom [SafetySelection]. Can be used to disable safety via [SafetySelection::Unsafe] /// Use a custom [SafetySelection]. Can be used to disable safety via [SafetySelection::Unsafe].
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]
pub fn with_safety(self, safety_selection: SafetySelection) -> VeilidAPIResult<Self> { pub fn with_safety(self, safety_selection: SafetySelection) -> VeilidAPIResult<Self> {
event!(target: "veilid_api", Level::DEBUG, event!(target: "veilid_api", Level::DEBUG,
@ -101,7 +101,7 @@ impl RoutingContext {
}) })
} }
/// Use a specified [Sequencing] preference, with or without privacy /// Use a specified [Sequencing] preference, with or without privacy.
#[instrument(target = "veilid_api", level = "debug", ret)] #[instrument(target = "veilid_api", level = "debug", ret)]
pub fn with_sequencing(self, sequencing: Sequencing) -> Self { pub fn with_sequencing(self, sequencing: Sequencing) -> Self {
event!(target: "veilid_api", Level::DEBUG, event!(target: "veilid_api", Level::DEBUG,
@ -124,7 +124,7 @@ impl RoutingContext {
} }
} }
/// Get the safety selection in use on this routing context /// Get the safety selection in use on this routing context.
pub fn safety(&self) -> SafetySelection { pub fn safety(&self) -> SafetySelection {
self.unlocked_inner.safety_selection self.unlocked_inner.safety_selection
} }
@ -136,7 +136,7 @@ impl RoutingContext {
} }
} }
/// Get the [VeilidAPI] object that created this [RoutingContext] /// Get the [VeilidAPI] object that created this [RoutingContext].
pub fn api(&self) -> VeilidAPI { pub fn api(&self) -> VeilidAPI {
self.api.clone() self.api.clone()
} }
@ -160,10 +160,10 @@ impl RoutingContext {
/// ///
/// Veilid apps may use this for arbitrary message passing. /// Veilid apps may use this for arbitrary message passing.
/// ///
/// * `target` - can be either a direct node id or a private route /// * `target` - can be either a direct node id or a private route.
/// * `message` - an arbitrary message blob of up to 32768 bytes /// * `message` - an arbitrary message blob of up to 32768 bytes.
/// ///
/// Returns an answer blob of up to 32768 bytes /// Returns an answer blob of up to 32768 bytes.
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]
pub async fn app_call(&self, target: Target, message: Vec<u8>) -> VeilidAPIResult<Vec<u8>> { pub async fn app_call(&self, target: Target, message: Vec<u8>) -> VeilidAPIResult<Vec<u8>> {
event!(target: "veilid_api", Level::DEBUG, event!(target: "veilid_api", Level::DEBUG,
@ -196,8 +196,8 @@ impl RoutingContext {
/// ///
/// Veilid apps may use this for arbitrary message passing. /// Veilid apps may use this for arbitrary message passing.
/// ///
/// * `target` - can be either a direct node id or a private route /// * `target` - can be either a direct node id or a private route.
/// * `message` - an arbitrary message blob of up to 32768 bytes /// * `message` - an arbitrary message blob of up to 32768 bytes.
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]
pub async fn app_message(&self, target: Target, message: Vec<u8>) -> VeilidAPIResult<()> { pub async fn app_message(&self, target: Target, message: Vec<u8>) -> VeilidAPIResult<()> {
event!(target: "veilid_api", Level::DEBUG, event!(target: "veilid_api", Level::DEBUG,
@ -228,7 +228,7 @@ impl RoutingContext {
/////////////////////////////////// ///////////////////////////////////
/// DHT Records /// DHT Records
/// Creates a new DHT record a specified crypto kind and schema /// Creates a new DHT record a specified crypto kind and schema.
/// ///
/// The record is considered 'open' after the create operation succeeds. /// The record is considered 'open' after the create operation succeeds.
/// ///
@ -251,7 +251,7 @@ impl RoutingContext {
.await .await
} }
/// Opens a DHT record at a specific key /// Opens a DHT record at a specific key.
/// ///
/// Associates a 'default_writer' secret if one is provided to provide writer capability. The /// Associates a 'default_writer' secret if one is provided to provide writer capability. The
/// writer can be overridden if specified here via the set_dht_value writer. /// writer can be overridden if specified here via the set_dht_value writer.
@ -261,7 +261,7 @@ impl RoutingContext {
/// without first closing it, which will keep the active 'watches' on the record but change the default writer or /// without first closing it, which will keep the active 'watches' on the record but change the default writer or
/// safety selection. /// safety selection.
/// ///
/// Returns the DHT record descriptor for the opened record if successful /// Returns the DHT record descriptor for the opened record if successful.
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]
pub async fn open_dht_record( pub async fn open_dht_record(
&self, &self,
@ -280,7 +280,7 @@ impl RoutingContext {
/// Closes a DHT record at a specific key that was opened with create_dht_record or open_dht_record. /// Closes a DHT record at a specific key that was opened with create_dht_record or open_dht_record.
/// ///
/// Closing a record allows you to re-open it with a different routing context /// Closing a record allows you to re-open it with a different routing context.
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]
pub async fn close_dht_record(&self, key: TypedKey) -> VeilidAPIResult<()> { pub async fn close_dht_record(&self, key: TypedKey) -> VeilidAPIResult<()> {
event!(target: "veilid_api", Level::DEBUG, event!(target: "veilid_api", Level::DEBUG,
@ -291,7 +291,7 @@ impl RoutingContext {
storage_manager.close_record(key).await storage_manager.close_record(key).await
} }
/// Deletes a DHT record at a specific key /// Deletes a DHT record at a specific key.
/// ///
/// If the record is opened, it must be closed before it is deleted. /// If the record is opened, it must be closed before it is deleted.
/// Deleting a record does not delete it from the network, but will remove the storage of the record /// Deleting a record does not delete it from the network, but will remove the storage of the record
@ -306,12 +306,12 @@ impl RoutingContext {
storage_manager.delete_record(key).await storage_manager.delete_record(key).await
} }
/// Gets the latest value of a subkey /// Gets the latest value of a subkey.
/// ///
/// May pull the latest value from the network, but by setting 'force_refresh' you can force a network data refresh /// May pull the latest value from the network, but by setting 'force_refresh' you can force a network data refresh.
/// ///
/// Returns `None` if the value subkey has not yet been set /// Returns `None` if the value subkey has not yet been set.
/// Returns `Some(data)` if the value subkey has valid data /// Returns `Some(data)` if the value subkey has valid data.
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]
pub async fn get_dht_value( pub async fn get_dht_value(
&self, &self,
@ -327,13 +327,13 @@ impl RoutingContext {
storage_manager.get_value(key, subkey, force_refresh).await storage_manager.get_value(key, subkey, force_refresh).await
} }
/// Pushes a changed subkey value to the network /// Pushes a changed subkey value to the network.
/// The DHT record must first by opened via open_dht_record or create_dht_record. /// The DHT record must first by opened via open_dht_record or create_dht_record.
/// ///
/// The writer, if specified, will override the 'default_writer' specified when the record is opened. /// The writer, if specified, will override the 'default_writer' specified when the record is opened.
/// ///
/// Returns `None` if the value was successfully put /// Returns `None` if the value was successfully put.
/// Returns `Some(data)` if the value put was older than the one available on the network /// Returns `Some(data)` if the value put was older than the one available on the network.
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]
pub async fn set_dht_value( pub async fn set_dht_value(
&self, &self,
@ -366,8 +366,8 @@ impl RoutingContext {
/// If the returned timestamp is zero it indicates that the watch creation or update has failed. In the case of a faild update, the watch is considered cancelled. /// If the returned timestamp is zero it indicates that the watch creation or update has failed. In the case of a faild update, the watch is considered cancelled.
/// ///
/// DHT watches are accepted with the following conditions: /// DHT watches are accepted with the following conditions:
/// * First-come first-served basis for arbitrary unauthenticated readers, up to network.dht.public_watch_limit per record /// * First-come first-served basis for arbitrary unauthenticated readers, up to network.dht.public_watch_limit per record.
/// * If a member (either the owner or a SMPL schema member) has opened the key for writing (even if no writing is performed) then the watch will be signed and guaranteed network.dht.member_watch_limit per writer /// * If a member (either the owner or a SMPL schema member) has opened the key for writing (even if no writing is performed) then the watch will be signed and guaranteed network.dht.member_watch_limit per writer.
/// ///
/// Members can be specified via the SMPL schema and do not need to allocate writable subkeys in order to offer a member watch capability. /// Members can be specified via the SMPL schema and do not need to allocate writable subkeys in order to offer a member watch capability.
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]
@ -388,14 +388,15 @@ impl RoutingContext {
.await .await
} }
/// Cancels a watch early /// Cancels a watch early.
/// ///
/// This is a convenience function that cancels watching all subkeys in a range. The subkeys specified here /// This is a convenience function that cancels watching all subkeys in a range. The subkeys specified here
/// are subtracted from the watched subkey range. If no range is specified, this is equivalent to cancelling the entire range of subkeys. /// are subtracted from the watched subkey range. If no range is specified, this is equivalent to cancelling the entire range of subkeys.
/// Only the subkey range is changed, the expiration and count remain the same. /// Only the subkey range is changed, the expiration and count remain the same.
/// If no subkeys remain, the watch is entirely cancelled and will receive no more updates. /// If no subkeys remain, the watch is entirely cancelled and will receive no more updates.
/// Returns Ok(true) if there is any remaining watch for this record ///
/// Returns Ok(false) if the entire watch has been cancelled /// Returns Ok(true) if there is any remaining watch for this record.
/// Returns Ok(false) if the entire watch has been cancelled.
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]
pub async fn cancel_dht_watch( pub async fn cancel_dht_watch(
&self, &self,
@ -421,32 +422,32 @@ impl RoutingContext {
/// ///
/// - DHTReportScope::Local /// - DHTReportScope::Local
/// Results will be only for a locally stored record. /// Results will be only for a locally stored record.
/// Useful for seeing what subkeys you have locally and which ones have not been retrieved /// Useful for seeing what subkeys you have locally and which ones have not been retrieved.
/// ///
/// - DHTReportScope::SyncGet /// - DHTReportScope::SyncGet
/// Return the local sequence numbers and the network sequence numbers with GetValue fanout parameters /// Return the local sequence numbers and the network sequence numbers with GetValue fanout parameters.
/// Provides an independent view of both the local sequence numbers and the network sequence numbers for nodes that /// Provides an independent view of both the local sequence numbers and the network sequence numbers for nodes that.
/// would be reached as if the local copy did not exist locally. /// would be reached as if the local copy did not exist locally.
/// Useful for determining if the current local copy should be updated from the network. /// Useful for determining if the current local copy should be updated from the network.
/// ///
/// - DHTReportScope::SyncSet /// - DHTReportScope::SyncSet
/// Return the local sequence numbers and the network sequence numbers with SetValue fanout parameters /// Return the local sequence numbers and the network sequence numbers with SetValue fanout parameters.
/// Provides an independent view of both the local sequence numbers and the network sequence numbers for nodes that /// Provides an independent view of both the local sequence numbers and the network sequence numbers for nodes that.
/// would be reached as if the local copy did not exist locally. /// would be reached as if the local copy did not exist locally.
/// Useful for determining if the unchanged local copy should be pushed to the network. /// Useful for determining if the unchanged local copy should be pushed to the network.
/// ///
/// - DHTReportScope::UpdateGet /// - DHTReportScope::UpdateGet
/// Return the local sequence numbers and the network sequence numbers with GetValue fanout parameters /// Return the local sequence numbers and the network sequence numbers with GetValue fanout parameters.
/// Provides an view of both the local sequence numbers and the network sequence numbers for nodes that /// Provides an view of both the local sequence numbers and the network sequence numbers for nodes that.
/// would be reached as if a GetValue operation were being performed, including accepting newer values from the network. /// would be reached as if a GetValue operation were being performed, including accepting newer values from the network.
/// Useful for determining which subkeys would change with a GetValue operation /// Useful for determining which subkeys would change with a GetValue operation.
/// ///
/// - DHTReportScope::UpdateSet /// - DHTReportScope::UpdateSet
/// Return the local sequence numbers and the network sequence numbers with SetValue fanout parameters /// Return the local sequence numbers and the network sequence numbers with SetValue fanout parameters.
/// Provides an view of both the local sequence numbers and the network sequence numbers for nodes that /// Provides an view of both the local sequence numbers and the network sequence numbers for nodes that.
/// would be reached as if a SetValue operation were being performed, including accepting newer values from the network. /// would be reached as if a SetValue operation were being performed, including accepting newer values from the network.
/// This simulates a SetValue with the initial sequence number incremented by 1, like a real SetValue would when updating. /// This simulates a SetValue with the initial sequence number incremented by 1, like a real SetValue would when updating.
/// Useful for determine which subkeys would change with an SetValue operation /// Useful for determine which subkeys would change with an SetValue operation.
/// ///
/// Returns a DHTRecordReport with the subkey ranges that were returned that overlapped the schema, and sequence numbers for each of the subkeys in the range. /// Returns a DHTRecordReport with the subkey ranges that were returned that overlapped the schema, and sequence numbers for each of the subkeys in the range.
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]

8
veilid-core/src/veilid_api/types/aligned_u64.rs
View File

@ -1,9 +1,9 @@
use super::*; use super::*;
/// Aligned u64 /// Aligned u64.
/// Required on 32-bit platforms for serialization because Rust aligns u64 on 4 byte boundaries /// Required on 32-bit platforms for serialization because Rust aligns u64 on 4 byte boundaries.
/// Some zero-copy serialization frameworks also want 8-byte alignment /// Some zero-copy serialization frameworks also want 8-byte alignment.
/// Supports serializing to string for JSON as well, since JSON can't handle 64-bit numbers to Javascript /// Supports serializing to string for JSON as well, since JSON can't handle 64-bit numbers to Javascript.
#[derive( #[derive(
Clone, Default, PartialEq, Eq, PartialOrd, Ord, Copy, Hash, Serialize, Deserialize, JsonSchema, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Copy, Hash, Serialize, Deserialize, JsonSchema,

18
veilid-core/src/veilid_api/types/app_message_call.rs
View File

@ -1,6 +1,6 @@
use super::*; use super::*;
/// Direct statement blob passed to hosting application for processing /// Direct statement blob passed to hosting application for processing.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[cfg_attr(target_arch = "wasm32", derive(Tsify))] #[cfg_attr(target_arch = "wasm32", derive(Tsify))]
pub struct VeilidAppMessage { pub struct VeilidAppMessage {
@ -33,23 +33,23 @@ impl VeilidAppMessage {
} }
} }
/// Some(sender) if the message was sent directly, None if received via a private/safety route /// Some(sender) if the message was sent directly, None if received via a private/safety route.
pub fn sender(&self) -> Option<&TypedKey> { pub fn sender(&self) -> Option<&TypedKey> {
self.sender.as_ref() self.sender.as_ref()
} }
/// Some(route_id) if the message was received over a private route, None if received only a safety route or directly /// Some(route_id) if the message was received over a private route, None if received only a safety route or directly.
pub fn route_id(&self) -> Option<&RouteId> { pub fn route_id(&self) -> Option<&RouteId> {
self.route_id.as_ref() self.route_id.as_ref()
} }
/// The content of the message to deliver to the application /// The content of the message to deliver to the application.
pub fn message(&self) -> &[u8] { pub fn message(&self) -> &[u8] {
&self.message &self.message
} }
} }
/// Direct question blob passed to hosting application for processing to send an eventual AppReply /// Direct question blob passed to hosting application for processing to send an eventual AppReply.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[cfg_attr(target_arch = "wasm32", derive(Tsify))] #[cfg_attr(target_arch = "wasm32", derive(Tsify))]
pub struct VeilidAppCall { pub struct VeilidAppCall {
@ -92,22 +92,22 @@ impl VeilidAppCall {
} }
} }
/// Some(sender) if the request was sent directly, None if received via a private/safety route /// Some(sender) if the request was sent directly, None if received via a private/safety route.
pub fn sender(&self) -> Option<&TypedKey> { pub fn sender(&self) -> Option<&TypedKey> {
self.sender.as_ref() self.sender.as_ref()
} }
/// Some(route_id) if the request was received over a private route, None if received only a safety route or directly /// Some(route_id) if the request was received over a private route, None if received only a safety route or directly.
pub fn route_id(&self) -> Option<&RouteId> { pub fn route_id(&self) -> Option<&RouteId> {
self.route_id.as_ref() self.route_id.as_ref()
} }
/// The content of the request to deliver to the application /// The content of the request to deliver to the application.
pub fn message(&self) -> &[u8] { pub fn message(&self) -> &[u8] {
&self.message &self.message
} }
/// The id to specify as `call_id` in the [VeilidAPI::app_call_reply] function /// The id to specify as `call_id` in the [VeilidAPI::app_call_reply] function.
pub fn id(&self) -> OperationId { pub fn id(&self) -> OperationId {
self.call_id self.call_id
} }

2
veilid-core/src/veilid_api/types/fourcc.rs
View File

@ -1,6 +1,6 @@
use super::*; use super::*;
/// FOURCC code /// FOURCC code.
#[derive( #[derive(
Copy, Default, Clone, Hash, PartialOrd, Ord, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Copy, Default, Clone, Hash, PartialOrd, Ord, PartialEq, Eq, Serialize, Deserialize, JsonSchema,
)] )]

16
veilid-core/src/veilid_api/types/safety.rs
View File

@ -43,7 +43,7 @@ impl Default for Stability {
} }
} }
/// The choice of safety route to include in compiled routes /// The choice of safety route to include in compiled routes.
#[derive( #[derive(
Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, JsonSchema, Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, JsonSchema,
)] )]
@ -54,9 +54,9 @@ impl Default for Stability {
)] )]
pub enum SafetySelection { pub enum SafetySelection {
/// Don't use a safety route, only specify the sequencing preference /// Don't use a safety route, only specify the sequencing preference.
Unsafe(Sequencing), Unsafe(Sequencing),
/// Use a safety route and parameters specified by a SafetySpec /// Use a safety route and parameters specified by a SafetySpec.
Safe(SafetySpec), Safe(SafetySpec),
} }
@ -75,20 +75,20 @@ impl Default for SafetySelection {
} }
} }
/// Options for safety routes (sender privacy) /// Options for safety routes (sender privacy).
#[derive( #[derive(
Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, JsonSchema, Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, JsonSchema,
)] )]
#[cfg_attr(target_arch = "wasm32", derive(Tsify))] #[cfg_attr(target_arch = "wasm32", derive(Tsify))]
pub struct SafetySpec { pub struct SafetySpec {
/// preferred safety route set id if it still exists /// Preferred safety route set id if it still exists.
#[schemars(with = "Option<String>")] #[schemars(with = "Option<String>")]
#[cfg_attr(target_arch = "wasm32", tsify(optional, type = "string"))] #[cfg_attr(target_arch = "wasm32", tsify(optional, type = "string"))]
pub preferred_route: Option<RouteId>, pub preferred_route: Option<RouteId>,
/// must be greater than 0 /// Must be greater than 0.
pub hop_count: usize, pub hop_count: usize,
/// prefer reliability over speed /// Prefer reliability over speed.
pub stability: Stability, pub stability: Stability,
/// prefer connection-oriented sequenced protocols /// Prefer connection-oriented sequenced protocols.
pub sequencing: Sequencing, pub sequencing: Sequencing,
} }

2
veilid-core/src/veilid_api/types/tunnel.rs
View File

@ -1,7 +1,7 @@
#[cfg(feature = "unstable-tunnels")] #[cfg(feature = "unstable-tunnels")]
use super::*; use super::*;
/// Tunnel identifier /// Tunnel identifier.
#[cfg(feature = "unstable-tunnels")] #[cfg(feature = "unstable-tunnels")]
pub type TunnelId = AlignedU64; pub type TunnelId = AlignedU64;

4
veilid-core/src/veilid_api/types/veilid_log.rs
View File

@ -1,6 +1,6 @@
use super::*; use super::*;
/// Log level for VeilidCore /// Log level for VeilidCore.
#[derive( #[derive(
Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Copy, Serialize, Deserialize, JsonSchema, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Copy, Serialize, Deserialize, JsonSchema,
)] )]
@ -79,7 +79,7 @@ impl fmt::Display for VeilidLogLevel {
write!(f, "{}", text) write!(f, "{}", text)
} }
} }
/// A VeilidCore log message with optional backtrace /// A VeilidCore log message with optional backtrace.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[cfg_attr(target_arch = "wasm32", derive(Tsify))] #[cfg_attr(target_arch = "wasm32", derive(Tsify))]
pub struct VeilidLog { pub struct VeilidLog {

2
veilid-core/src/veilid_api/types/veilid_state.rs
View File

@ -1,6 +1,6 @@
use super::*; use super::*;
/// Attachment abstraction for network 'signal strength' /// Attachment abstraction for network 'signal strength'.
#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize, JsonSchema)] #[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize, JsonSchema)]
#[cfg_attr( #[cfg_attr(
target_arch = "wasm32", target_arch = "wasm32",

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

@ -20,7 +20,7 @@ cfg_if::cfg_if! {
pub type ConfigCallbackReturn = VeilidAPIResult<Box<dyn core::any::Any + Send>>; pub type ConfigCallbackReturn = VeilidAPIResult<Box<dyn core::any::Any + Send>>;
pub type ConfigCallback = Arc<dyn Fn(String) -> ConfigCallbackReturn + Send + Sync>; pub type ConfigCallback = Arc<dyn Fn(String) -> ConfigCallbackReturn + Send + Sync>;
/// Enable and configure HTTPS access to the Veilid node /// Enable and configure HTTPS access to the Veilid node.
/// ///
/// ```yaml /// ```yaml
/// https: /// https:
@ -51,7 +51,7 @@ impl Default for VeilidConfigHTTPS {
} }
} }
/// Enable and configure HTTP access to the Veilid node /// Enable and configure HTTP access to the Veilid node.
/// ///
/// ```yaml /// ```yaml
/// http: /// http:
@ -82,9 +82,9 @@ impl Default for VeilidConfigHTTP {
} }
} }
/// Application configuration /// Application configuration.
/// ///
/// Configure web access to the Progressive Web App (PWA) /// Configure web access to the Progressive Web App (PWA).
/// ///
/// To be implemented... /// To be implemented...
/// ///
@ -95,7 +95,7 @@ pub struct VeilidConfigApplication {
pub http: VeilidConfigHTTP, pub http: VeilidConfigHTTP,
} }
/// Enable and configure UDP /// Enable and configure UDP.
/// ///
/// ```yaml /// ```yaml
/// udp: /// udp:
@ -133,7 +133,7 @@ impl Default for VeilidConfigUDP {
} }
} }
/// Enable and configure TCP /// Enable and configure TCP.
/// ///
/// ```yaml /// ```yaml
/// tcp: /// tcp:
@ -175,7 +175,7 @@ impl Default for VeilidConfigTCP {
} }
} }
/// Enable and configure Web Sockets /// Enable and configure Web Sockets.
/// ///
/// ```yaml /// ```yaml
/// ws: /// ws:
@ -221,7 +221,7 @@ impl Default for VeilidConfigWS {
} }
} }
/// Enable and configure Secure Web Sockets /// Enable and configure Secure Web Sockets.
/// ///
/// ```yaml /// ```yaml
/// wss: /// wss:
@ -258,7 +258,7 @@ impl Default for VeilidConfigWSS {
} }
} }
/// Configure Network Protocols /// Configure Network Protocols.
/// ///
/// Veilid can communicate over UDP, TCP, and Web Sockets. /// Veilid can communicate over UDP, TCP, and Web Sockets.
/// ///
@ -275,7 +275,7 @@ pub struct VeilidConfigProtocol {
pub wss: VeilidConfigWSS, pub wss: VeilidConfigWSS,
} }
/// Configure TLS /// Configure TLS.
/// ///
/// ```yaml /// ```yaml
/// tls: /// tls:
@ -326,7 +326,7 @@ pub fn get_default_ssl_directory(sub_path: &str) -> String {
} }
} }
/// Configure the Distributed Hash Table (DHT) /// Configure the Distributed Hash Table (DHT).
/// ///
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[cfg_attr(target_arch = "wasm32", derive(Tsify))] #[cfg_attr(target_arch = "wasm32", derive(Tsify))]
@ -410,7 +410,7 @@ impl Default for VeilidConfigDHT {
} }
} }
/// Configure RPC /// Configure RPC.
/// ///
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[cfg_attr(target_arch = "wasm32", derive(Tsify))] #[cfg_attr(target_arch = "wasm32", derive(Tsify))]
@ -440,7 +440,7 @@ impl Default for VeilidConfigRPC {
} }
} }
/// Configure the network routing table /// Configure the network routing table.
/// ///
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[cfg_attr(target_arch = "wasm32", derive(Tsify))] #[cfg_attr(target_arch = "wasm32", derive(Tsify))]
@ -721,9 +721,9 @@ pub struct VeilidConfigInner {
pub network: VeilidConfigNetwork, pub network: VeilidConfigNetwork,
} }
/// The Veilid Configuration /// The Veilid Configuration.
/// ///
/// Veilid is configured /// Veilid is configured.
#[derive(Clone)] #[derive(Clone)]
pub struct VeilidConfig { pub struct VeilidConfig {
update_cb: Option<UpdateCallback>, update_cb: Option<UpdateCallback>,
@ -1223,8 +1223,8 @@ impl VeilidConfig {
Ok((node_id, node_id_secret)) Ok((node_id, node_id_secret))
} }
/// Get the node id from config if one is specified /// Get the node id from config if one is specified.
/// Must be done -after- protected store startup /// Must be done -after- protected store startup.
#[cfg_attr(test, allow(unused_variables))] #[cfg_attr(test, allow(unused_variables))]
pub async fn init_node_ids( pub async fn init_node_ids(
&self, &self,
@ -1263,7 +1263,7 @@ impl VeilidConfig {
} }
} }
/// Return the default veilid config as a json object /// Return the default veilid config as a json object.
pub fn default_veilid_config() -> String { pub fn default_veilid_config() -> String {
serialize_json(VeilidConfigInner::default()) serialize_json(VeilidConfigInner::default())
} }