config change

This commit is contained in:
John Smith 2022-02-09 09:47:36 -05:00
parent 70960fa592
commit b9862b0016
22 changed files with 880 additions and 1235 deletions

View file

@ -63,6 +63,7 @@ keyvaluedb-sqlite = { path = "../external/keyvaluedb/keyvaluedb-sqlite" }
data-encoding = { version = "^2" }
serde = { version = "^1", features = ["derive" ] }
serde_cbor = { version = "^0" }
serde_json = { version = "^1" }
async_executors = { version = "^0", default-features = false, features = [ "async_std" ]}
socket2 = "^0"
bugsalot = "^0"
@ -84,6 +85,7 @@ keyvaluedb-web = { path = "../external/keyvaluedb/keyvaluedb-web" }
data-encoding = { version = "^2", default_features = false, features = ["alloc"] }
serde = { version = "^1", default-features = false, features = ["derive", "alloc"] }
serde_cbor = { version = "^0", default-features = false, features = ["alloc"] }
serde_json = { version = "^1", default-features = false, features = ["alloc"] }
getrandom = { version = "^0", features = ["js"] }
ws_stream_wasm = "^0"
async_executors = { version = "^0", default-features = false, features = [ "bindgen" ]}

View file

@ -14,11 +14,6 @@ cfg_if! {
}
}
pub struct VeilidCoreSetup {
pub update_callback: UpdateCallback,
pub config_callback: ConfigCallback,
}
pub struct VeilidCoreContext {
pub config: VeilidConfig,
pub protected_store: ProtectedStore,
@ -29,46 +24,56 @@ pub struct VeilidCoreContext {
}
impl VeilidCoreContext {
async fn new(setup: VeilidCoreSetup) -> Result<VeilidCoreContext, VeilidAPIError> {
// Start up api logging early if it's in the config
let api_log_level: VeilidConfigLogLevel =
*(setup.config_callback)("api_log_level".to_owned())
.map_err(|e| VeilidAPIError::ParseError {
message: "Failed to get api_log_level".to_owned(),
value: e,
})?
.downcast()
.map_err(|e| VeilidAPIError::ParseError {
message: "Incorrect type for key 'api_log_level'".to_owned(),
value: format!("Invalid type: {:?}", e.type_id()),
})?;
if api_log_level != VeilidConfigLogLevel::Off {
ApiLogger::init(
api_log_level.to_level_filter(),
setup.update_callback.clone(),
);
for ig in crate::DEFAULT_LOG_IGNORE_LIST {
ApiLogger::add_filter_ignore_str(ig);
}
async fn new_with_config_callback(
update_callback: UpdateCallback,
config_callback: ConfigCallback,
) -> Result<VeilidCoreContext, VeilidAPIError> {
// Set up config from callback
trace!("VeilidCoreContext::new_with_config_callback init config");
let mut config = VeilidConfig::new();
if let Err(e) = config.init(config_callback).await {
return Err(VeilidAPIError::Internal { message: e });
}
trace!("VeilidCoreContext::new starting");
Self::new_common(update_callback, config).await
}
async fn new_with_config_json(
update_callback: UpdateCallback,
config_json: String,
) -> Result<VeilidCoreContext, VeilidAPIError> {
// Set up config from callback
trace!("VeilidCoreContext::new_with_config_json init config");
let mut config = VeilidConfig::new();
if let Err(e) = config.init_from_json(config_json).await {
return Err(VeilidAPIError::Internal { message: e });
}
Self::new_common(update_callback, config).await
}
async fn new_common(
update_callback: UpdateCallback,
config: VeilidConfig,
) -> Result<VeilidCoreContext, VeilidAPIError> {
cfg_if! {
if #[cfg(target_os = "android")] {
if utils::android::ANDROID_GLOBALS.lock().is_none() {
error!("Android globals are not set up");
config.terminate().await;
return Err("Android globals are not set up".to_owned());
}
}
}
// Set up config
trace!("VeilidCoreContext::new init config");
let mut config = VeilidConfig::new();
if let Err(e) = config.init(setup.config_callback).await {
ApiLogger::terminate();
return Err(VeilidAPIError::Internal(e));
// Start up api logging
let api_log_level: VeilidConfigLogLevel = config.get().api_log_level;
if api_log_level != VeilidConfigLogLevel::Off {
ApiLogger::init(api_log_level.to_level_filter(), update_callback.clone());
for ig in crate::DEFAULT_LOG_IGNORE_LIST {
ApiLogger::add_filter_ignore_str(ig);
}
info!("Veilid API logging initialized");
}
// Set up protected store
@ -77,7 +82,7 @@ impl VeilidCoreContext {
if let Err(e) = protected_store.init().await {
config.terminate().await;
ApiLogger::terminate();
return Err(VeilidAPIError::Internal(e));
return Err(VeilidAPIError::Internal { message: e });
}
// Init node id from config now that protected store is set up
@ -85,7 +90,7 @@ impl VeilidCoreContext {
protected_store.terminate().await;
config.terminate().await;
ApiLogger::terminate();
return Err(VeilidAPIError::Internal(e));
return Err(VeilidAPIError::Internal { message: e });
}
// Set up tablestore
@ -95,7 +100,7 @@ impl VeilidCoreContext {
protected_store.terminate().await;
config.terminate().await;
ApiLogger::terminate();
return Err(VeilidAPIError::Internal(e));
return Err(VeilidAPIError::Internal { message: e });
}
// Set up crypto
@ -106,7 +111,7 @@ impl VeilidCoreContext {
protected_store.terminate().await;
config.terminate().await;
ApiLogger::terminate();
return Err(VeilidAPIError::Internal(e));
return Err(VeilidAPIError::Internal { message: e });
}
// Set up block store
@ -118,18 +123,17 @@ impl VeilidCoreContext {
protected_store.terminate().await;
config.terminate().await;
ApiLogger::terminate();
return Err(VeilidAPIError::Internal(e));
return Err(VeilidAPIError::Internal { message: e });
}
// Set up attachment manager
trace!("VeilidCoreContext::new init attachment manager");
let cb = setup.update_callback;
let attachment_manager =
AttachmentManager::new(config.clone(), table_store.clone(), crypto.clone());
if let Err(e) = attachment_manager
.init(Arc::new(
move |_old_state: AttachmentState, new_state: AttachmentState| {
cb(VeilidUpdate::Attachment(new_state))
update_callback(VeilidUpdate::Attachment { state: new_state })
},
))
.await
@ -140,7 +144,7 @@ impl VeilidCoreContext {
protected_store.terminate().await;
config.terminate().await;
ApiLogger::terminate();
return Err(VeilidAPIError::Internal(e));
return Err(VeilidAPIError::Internal { message: e });
}
Ok(VeilidCoreContext {
@ -172,7 +176,10 @@ impl VeilidCoreContext {
static INITIALIZED: AsyncMutex<bool> = AsyncMutex::new(false);
pub async fn api_startup(setup: VeilidCoreSetup) -> Result<VeilidAPI, VeilidAPIError> {
pub async fn api_startup(
update_callback: UpdateCallback,
config_callback: ConfigCallback,
) -> Result<VeilidAPI, VeilidAPIError> {
// See if we have an API started up already
let mut initialized_lock = INITIALIZED.lock().await;
if *initialized_lock {
@ -180,7 +187,29 @@ pub async fn api_startup(setup: VeilidCoreSetup) -> Result<VeilidAPI, VeilidAPIE
}
// Create core context
let context = VeilidCoreContext::new(setup).await?;
let context =
VeilidCoreContext::new_with_config_callback(update_callback, config_callback).await?;
// Return an API object around our context
let veilid_api = VeilidAPI::new(context);
*initialized_lock = true;
Ok(veilid_api)
}
pub async fn api_startup_json(
update_callback: UpdateCallback,
config_json: String,
) -> Result<VeilidAPI, VeilidAPIError> {
// See if we have an API started up already
let mut initialized_lock = INITIALIZED.lock().await;
if *initialized_lock {
return Err(VeilidAPIError::AlreadyInitialized);
}
// Create core context
let context = VeilidCoreContext::new_with_config_json(update_callback, config_json).await?;
// Return an API object around our context
let veilid_api = VeilidAPI::new(context);

View file

@ -26,7 +26,7 @@ mod veilid_rng;
pub mod xx;
pub use self::attachment_manager::AttachmentState;
pub use self::core_context::{api_startup, VeilidCoreSetup};
pub use self::core_context::{api_startup, api_startup_json, UpdateCallback};
pub use self::veilid_api::*;
pub use self::veilid_config::*;

View file

@ -6,22 +6,10 @@ use crate::*;
static LOREM_IPSUM:&[u8] = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. ";
fn setup_veilid_core() -> VeilidCoreSetup {
VeilidCoreSetup {
update_callback: Arc::new(
move |veilid_update: VeilidUpdate| -> SystemPinBoxFuture<()> {
Box::pin(async move {
trace!("update_callback: {:?}", veilid_update);
})
},
),
config_callback: Arc::new(config_callback),
}
}
async fn startup() -> VeilidAPI {
trace!("test_table_store: starting");
let api = api_startup(setup_veilid_core())
let (update_callback, config_callback) = setup_veilid_core();
let api = api_startup(update_callback, config_callback)
.await
.expect("startup failed");
api

View file

@ -8,7 +8,8 @@ use crate::*;
pub async fn test_envelope_round_trip() {
info!("--- test envelope round trip ---");
let api = api_startup(setup_veilid_core())
let (update_callback, config_callback) = setup_veilid_core();
let api = api_startup(update_callback, config_callback)
.await
.expect("startup failed");

View file

@ -3,22 +3,10 @@ use crate::intf::*;
use crate::xx::*;
use crate::*;
fn setup_veilid_core() -> VeilidCoreSetup {
VeilidCoreSetup {
update_callback: Arc::new(
move |veilid_update: VeilidUpdate| -> SystemPinBoxFuture<()> {
Box::pin(async move {
trace!("update_callback: {:?}", veilid_update);
})
},
),
config_callback: Arc::new(config_callback),
}
}
async fn startup() -> VeilidAPI {
trace!("test_table_store: starting");
api_startup(setup_veilid_core())
let (update_callback, config_callback) = setup_veilid_core();
api_startup(update_callback, config_callback)
.await
.expect("startup failed")
}

View file

@ -4,22 +4,10 @@ use crate::intf::*;
use crate::xx::*;
use crate::*;
fn setup_veilid_core() -> VeilidCoreSetup {
VeilidCoreSetup {
update_callback: Arc::new(
move |veilid_update: VeilidUpdate| -> SystemPinBoxFuture<()> {
Box::pin(async move {
trace!("update_callback: {:?}", veilid_update);
})
},
),
config_callback: Arc::new(config_callback),
}
}
async fn startup() -> VeilidAPI {
trace!("test_table_store: starting");
api_startup(setup_veilid_core())
let (update_callback, config_callback) = setup_veilid_core();
api_startup(update_callback, config_callback)
.await
.expect("startup failed")
}

View file

@ -158,20 +158,20 @@ cfg_if! {
}
}
pub fn setup_veilid_core() -> VeilidCoreSetup {
VeilidCoreSetup {
update_callback: Arc::new(
pub fn setup_veilid_core() -> (UpdateCallback, ConfigCallback) {
(
Arc::new(
move |veilid_update: VeilidUpdate| -> SystemPinBoxFuture<()> {
Box::pin(async move {
trace!("update_callback: {:?}", veilid_update);
})
},
),
config_callback: Arc::new(config_callback),
}
Arc::new(config_callback),
)
}
pub fn config_callback(key: String) -> ConfigCallbackReturn {
fn config_callback(key: String) -> ConfigCallbackReturn {
match key.as_str() {
"program_name" => Ok(Box::new(String::from("Veilid"))),
"namespace" => Ok(Box::new(String::from(""))),

View file

@ -4,7 +4,8 @@ use crate::*;
pub async fn test_startup_shutdown() {
trace!("test_startup_shutdown: starting");
let api = api_startup(setup_veilid_core())
let (update_callback, config_callback) = setup_veilid_core();
let api = api_startup(update_callback, config_callback)
.await
.expect("startup failed");
trace!("test_startup_shutdown: shutting down");
@ -14,19 +15,26 @@ pub async fn test_startup_shutdown() {
pub async fn test_attach_detach() {
info!("--- test normal order ---");
let api = api_startup(setup_veilid_core())
let (update_callback, config_callback) = setup_veilid_core();
let api = api_startup(update_callback, config_callback)
.await
.expect("startup failed");
api.attach().await.unwrap();
intf::sleep(5000).await;
api.detach().await.unwrap();
api.wait_for_update(VeilidUpdate::Attachment(AttachmentState::Detached), None)
.await
.unwrap();
api.wait_for_update(
VeilidUpdate::Attachment {
state: AttachmentState::Detached,
},
None,
)
.await
.unwrap();
api.shutdown().await;
info!("--- test auto detach ---");
let api = api_startup(setup_veilid_core())
let (update_callback, config_callback) = setup_veilid_core();
let api = api_startup(update_callback, config_callback)
.await
.expect("startup failed");
api.attach().await.unwrap();
@ -34,7 +42,8 @@ pub async fn test_attach_detach() {
api.shutdown().await;
info!("--- test detach without attach ---");
let api = api_startup(setup_veilid_core())
let (update_callback, config_callback) = setup_veilid_core();
let api = api_startup(update_callback, config_callback)
.await
.expect("startup failed");
api.detach().await.unwrap();

View file

@ -37,10 +37,18 @@ pub enum VeilidAPIError {
AlreadyInitialized,
Timeout,
Shutdown,
NodeNotFound(NodeId),
NoDialInfo(NodeId),
Internal(String),
Unimplemented(String),
NodeNotFound {
node_id: NodeId,
},
NoDialInfo {
node_id: NodeId,
},
Internal {
message: String,
},
Unimplemented {
message: String,
},
ParseError {
message: String,
value: String,
@ -63,10 +71,18 @@ impl fmt::Display for VeilidAPIError {
VeilidAPIError::AlreadyInitialized => write!(f, "VeilidAPIError::AlreadyInitialized"),
VeilidAPIError::Timeout => write!(f, "VeilidAPIError::Timeout"),
VeilidAPIError::Shutdown => write!(f, "VeilidAPIError::Shutdown"),
VeilidAPIError::NodeNotFound(ni) => write!(f, "VeilidAPIError::NodeNotFound({})", ni),
VeilidAPIError::NoDialInfo(ni) => write!(f, "VeilidAPIError::NoDialInfo({})", ni),
VeilidAPIError::Internal(e) => write!(f, "VeilidAPIError::Internal({})", e),
VeilidAPIError::Unimplemented(e) => write!(f, "VeilidAPIError::Unimplemented({})", e),
VeilidAPIError::NodeNotFound { node_id } => {
write!(f, "VeilidAPIError::NodeNotFound({})", node_id)
}
VeilidAPIError::NoDialInfo { node_id } => {
write!(f, "VeilidAPIError::NoDialInfo({})", node_id)
}
VeilidAPIError::Internal { message } => {
write!(f, "VeilidAPIError::Internal({})", message)
}
VeilidAPIError::Unimplemented { message } => {
write!(f, "VeilidAPIError::Unimplemented({})", message)
}
VeilidAPIError::ParseError { message, value } => {
write!(f, "VeilidAPIError::ParseError({}: {})", message, value)
}
@ -95,10 +111,12 @@ impl fmt::Display for VeilidAPIError {
fn convert_rpc_error(x: RPCError) -> VeilidAPIError {
match x {
RPCError::Timeout => VeilidAPIError::Timeout,
RPCError::Unimplemented(s) => VeilidAPIError::Unimplemented(s),
RPCError::Internal(s) => VeilidAPIError::Internal(s),
RPCError::Protocol(s) => VeilidAPIError::Internal(s),
RPCError::InvalidFormat => VeilidAPIError::Internal("Invalid packet format".to_owned()),
RPCError::Unimplemented(s) => VeilidAPIError::Unimplemented { message: s },
RPCError::Internal(s) => VeilidAPIError::Internal { message: s },
RPCError::Protocol(s) => VeilidAPIError::Internal { message: s },
RPCError::InvalidFormat => VeilidAPIError::Internal {
message: "Invalid packet format".to_owned(),
},
}
}
@ -147,7 +165,9 @@ pub enum VeilidUpdate {
log_level: VeilidLogLevel,
message: String,
},
Attachment(AttachmentState),
Attachment {
state: AttachmentState,
},
}
#[derive(Debug, Clone, Serialize, Deserialize)]
@ -1209,9 +1229,9 @@ impl VeilidAPI {
} => {
// No point in waiting for a log
}
VeilidUpdate::Attachment(cs) => {
VeilidUpdate::Attachment { state } => {
self.attachment_manager()?
.wait_for_state(cs, timeout_ms)
.wait_for_state(state, timeout_ms)
.await;
}
}
@ -1230,7 +1250,7 @@ impl VeilidAPI {
let rpc = self.rpc_processor()?;
let routing_table = rpc.routing_table();
let node_ref = match routing_table.lookup_node_ref(node_id.key) {
None => return Err(VeilidAPIError::NodeNotFound(node_id)),
None => return Err(VeilidAPIError::NodeNotFound { node_id }),
Some(nr) => nr,
};
let info_answer = rpc
@ -1250,7 +1270,7 @@ impl VeilidAPI {
let rpc = self.rpc_processor()?;
let routing_table = rpc.routing_table();
let node_ref = match routing_table.lookup_node_ref(node_id.key) {
None => return Err(VeilidAPIError::NodeNotFound(node_id)),
None => return Err(VeilidAPIError::NodeNotFound { node_id }),
Some(nr) => nr,
};
rpc.rpc_call_validate_dial_info(node_ref.clone(), dial_info, redirect, alternate_port)

View file

@ -15,7 +15,7 @@ cfg_if! {
}
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigHTTPS {
pub enabled: bool,
pub listen_address: String,
@ -23,7 +23,7 @@ pub struct VeilidConfigHTTPS {
pub url: Option<String>, // Fixed URL is not optional for TLS-based protocols and is dynamically validated
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigHTTP {
pub enabled: bool,
pub listen_address: String,
@ -31,13 +31,13 @@ pub struct VeilidConfigHTTP {
pub url: Option<String>,
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigApplication {
pub https: VeilidConfigHTTPS,
pub http: VeilidConfigHTTP,
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigUDP {
pub enabled: bool,
pub socket_pool_size: u32,
@ -45,7 +45,7 @@ pub struct VeilidConfigUDP {
pub public_address: Option<String>,
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigTCP {
pub connect: bool,
pub listen: bool,
@ -54,7 +54,7 @@ pub struct VeilidConfigTCP {
pub public_address: Option<String>,
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigWS {
pub connect: bool,
pub listen: bool,
@ -64,7 +64,7 @@ pub struct VeilidConfigWS {
pub url: Option<String>,
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigWSS {
pub connect: bool,
pub listen: bool,
@ -74,7 +74,7 @@ pub struct VeilidConfigWSS {
pub url: Option<String>, // Fixed URL is not optional for TLS-based protocols and is dynamically validated
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigProtocol {
pub udp: VeilidConfigUDP,
pub tcp: VeilidConfigTCP,
@ -82,14 +82,14 @@ pub struct VeilidConfigProtocol {
pub wss: VeilidConfigWSS,
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigTLS {
pub certificate_path: String,
pub private_key_path: String,
pub connection_initial_timeout_ms: u32,
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigDHT {
pub resolve_node_timeout_ms: Option<u32>,
pub resolve_node_count: u32,
@ -106,7 +106,7 @@ pub struct VeilidConfigDHT {
pub validate_dial_info_receipt_time_ms: u32,
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigRPC {
pub concurrency: u32,
pub queue_size: u32,
@ -116,7 +116,7 @@ pub struct VeilidConfigRPC {
pub max_route_hop_count: u8,
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigLeases {
pub max_server_signal_leases: u32,
pub max_server_relay_leases: u32,
@ -124,7 +124,7 @@ pub struct VeilidConfigLeases {
pub max_client_relay_leases: u32,
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigNetwork {
pub max_connections: u32,
pub connection_initial_timeout_ms: u32,
@ -143,19 +143,19 @@ pub struct VeilidConfigNetwork {
pub leases: VeilidConfigLeases,
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigTableStore {
pub directory: String,
pub delete: bool,
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigBlockStore {
pub directory: String,
pub delete: bool,
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigProtectedStore {
pub allow_insecure_fallback: bool,
pub always_use_insecure_storage: bool,
@ -163,7 +163,7 @@ pub struct VeilidConfigProtectedStore {
pub delete: bool,
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigCapabilities {
pub protocol_udp: bool,
pub protocol_connect_tcp: bool,
@ -202,7 +202,7 @@ impl Default for VeilidConfigLogLevel {
}
}
#[derive(Default, Clone)]
#[derive(Default, Clone, Serialize, Deserialize)]
pub struct VeilidConfigInner {
pub program_name: String,
pub namespace: String,
@ -235,6 +235,16 @@ impl VeilidConfig {
}
}
pub async fn init_from_json(&mut self, config: String) -> Result<(), String> {
let mut inner = self.inner.write();
*inner = serde_json::from_str(&config).map_err(map_to_string)?;
// Validate settings
self.validate().await?;
Ok(())
}
pub async fn init(&mut self, cb: ConfigCallback) -> Result<(), String> {
macro_rules! get_config {
($key:expr) => {