use std::fmt;
use std::sync::Arc;
use crate::plugin::{PluginChain, PluginOptions};
use crate::{Error, MemoryInput, MemoryOutput, Result};
#[derive(Clone)]
pub enum ProcessorInput {
Native(PluginOptions),
Memory(Arc<MemoryInput>),
}
impl fmt::Debug for ProcessorInput {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Native(value) => formatter.debug_tuple("Native").field(value).finish(),
Self::Memory(_) => formatter.debug_tuple("Memory").finish(),
}
}
}
#[derive(Clone)]
pub enum ProcessorOutput {
Native(PluginOptions),
Memory(Arc<MemoryOutput>),
}
impl fmt::Debug for ProcessorOutput {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Native(value) => formatter.debug_tuple("Native").field(value).finish(),
Self::Memory(_) => formatter.debug_tuple("Memory").finish(),
}
}
}
#[derive(Debug, Clone)]
pub struct ProcessorConfig {
pub ignore_joint_termination: bool,
pub buffer_size: i64,
pub max_flushed_packets: i64,
pub max_input_packets: i64,
pub max_output_packets: i64,
pub initial_input_packets: i64,
pub add_input_stuffing: [i64; 2],
pub add_start_stuffing: i64,
pub add_stop_stuffing: i64,
pub bitrate: i64,
pub bitrate_adjust_interval: i64,
pub receive_timeout: i64,
pub log_plugin_index: bool,
pub application_name: String,
pub input: Option<ProcessorInput>,
pub plugins: PluginChain,
pub output: Option<ProcessorOutput>,
}
impl Default for ProcessorConfig {
fn default() -> Self {
Self {
ignore_joint_termination: false,
buffer_size: 16 * 1024 * 1024,
max_flushed_packets: 0,
max_input_packets: 0,
max_output_packets: 0,
initial_input_packets: 0,
add_input_stuffing: [0, 0],
add_start_stuffing: 0,
add_stop_stuffing: 0,
bitrate: 0,
bitrate_adjust_interval: 5_000,
receive_timeout: 0,
log_plugin_index: false,
application_name: String::new(),
input: None,
plugins: PluginChain::default(),
output: None,
}
}
}
pub(crate) fn validate(config: &ProcessorConfig) -> Result<()> {
for value in [
config.buffer_size,
config.max_flushed_packets,
config.max_input_packets,
config.max_output_packets,
config.initial_input_packets,
config.add_input_stuffing[0],
config.add_input_stuffing[1],
config.add_start_stuffing,
config.add_stop_stuffing,
config.bitrate,
config.bitrate_adjust_interval,
config.receive_timeout,
] {
if !fits_native_long(value) {
return Err(Error::InvalidArgument {
field: "processor option",
message: "does not fit the native long type".to_owned(),
});
}
}
if let Some(ProcessorInput::Native(plugin)) = &config.input {
plugin.validate_not_memory("input")?;
}
if let Some(ProcessorOutput::Native(plugin)) = &config.output {
plugin.validate_not_memory("output")?;
}
for plugin in config.plugins.iter() {
plugin.validate_not_memory("plugins")?;
}
Ok(())
}
pub(crate) fn memory_input(config: &ProcessorConfig) -> Option<Arc<MemoryInput>> {
match &config.input {
Some(ProcessorInput::Memory(endpoint)) => Some(Arc::clone(endpoint)),
_ => None,
}
}
pub(crate) fn memory_output(config: &ProcessorConfig) -> Option<Arc<MemoryOutput>> {
match &config.output {
Some(ProcessorOutput::Memory(endpoint)) => Some(Arc::clone(endpoint)),
_ => None,
}
}
fn fits_native_long(value: i64) -> bool {
size_of::<std::ffi::c_long>() != size_of::<i32>()
|| (i64::from(i32::MIN)..=i64::from(i32::MAX)).contains(&value)
}