#[cfg(feature = "ws-client")]
use crate::api::network_config::NetworkConfig;
use crate::error::NetError;
use tokio::sync::Semaphore;
#[cfg_attr(
feature = "ws-client",
doc = "
When `ws-client` is enabled, configure a provider in the nested
[`NetworkConfig`](crate::network::NetworkConfig) before constructing [`crate::OpenNet`],
unless the host application has already installed a process-wide rustls provider."
)]
#[derive(Clone, Debug)]
pub struct OpenNetConfig {
#[cfg(feature = "quality-doctor")]
pub(crate) quality_doctor: crate::quality::QualityDoctorConfig,
pub(crate) runtime_worker_threads: Option<usize>,
pub(crate) async_queue_capacity: usize,
pub(crate) sync_queue_capacity: usize,
#[cfg(feature = "ws-client")]
pub(crate) network_config: NetworkConfig,
}
impl Default for OpenNetConfig {
fn default() -> Self {
Self {
#[cfg(feature = "quality-doctor")]
quality_doctor: crate::quality::QualityDoctorConfig::default(),
runtime_worker_threads: None,
async_queue_capacity: 128,
sync_queue_capacity: 128,
#[cfg(feature = "ws-client")]
network_config: NetworkConfig::default(),
}
}
}
impl OpenNetConfig {
#[cfg(feature = "quality-doctor")]
pub fn with_quality_doctor(mut self, config: crate::quality::QualityDoctorConfig) -> Self {
self.quality_doctor = config;
self
}
pub fn with_runtime_worker_threads(mut self, threads: usize) -> Self {
self.runtime_worker_threads = Some(threads);
self
}
pub fn with_async_queue_capacity(mut self, capacity: usize) -> Self {
self.async_queue_capacity = capacity;
self
}
pub fn with_sync_queue_capacity(mut self, capacity: usize) -> Self {
self.sync_queue_capacity = capacity;
self
}
#[cfg(feature = "ws-client")]
pub fn with_network_config(mut self, config: NetworkConfig) -> Self {
self.network_config = config;
self
}
pub fn runtime_worker_threads(&self) -> Option<usize> {
self.runtime_worker_threads
}
pub fn async_queue_capacity(&self) -> usize {
self.async_queue_capacity
}
pub fn sync_queue_capacity(&self) -> usize {
self.sync_queue_capacity
}
#[cfg(feature = "ws-client")]
pub fn network_config(&self) -> &NetworkConfig {
&self.network_config
}
pub fn validate(&self) -> Result<(), NetError> {
#[cfg(feature = "quality-doctor")]
self.quality_doctor
.validate()
.map_err(|_| NetError::config("quality_doctor", "invalid diagnostic configuration"))?;
if self.runtime_worker_threads.is_some_and(|threads| {
threads == 0 || threads > crate::common::common_engine::MAX_RUNTIME_WORKER_THREADS
}) {
return Err(NetError::config(
"runtime_worker_threads",
"must be between 1 and 256",
));
}
for (field, capacity) in [
("async_queue_capacity", self.async_queue_capacity),
("sync_queue_capacity", self.sync_queue_capacity),
] {
if capacity == 0 || capacity > Semaphore::MAX_PERMITS {
return Err(NetError::config(
field,
"must be between 1 and Semaphore::MAX_PERMITS",
));
}
}
#[cfg(feature = "ws-client")]
self.network_config.validate()?;
Ok(())
}
}
#[cfg(all(test, feature = "ws-client"))]
mod validation_tests {
use super::*;
use crate::network::RootCertificateMode;
#[test]
fn engine_validation_includes_nested_network_configuration() -> Result<(), NetError> {
let mut network = NetworkConfig::default();
network.tls.root_mode = RootCertificateMode::Replace;
let config = OpenNetConfig::default().with_network_config(network);
if !matches!(config.validate(), Err(ref __classified_error_0) if matches!(__classified_error_0.kind(), crate::error::ErrorKind::InvalidConfig))
{
return Err(NetError::from(crate::error::ErrorKind::Internal));
}
Ok(())
}
}