use std::time::Duration;
use crate::compress::COMPRESS_TYPE_ZSTD;
use crate::error::{Result, TmslError};
fn validate_nonzero_size(field: &str, value: u64) -> Result<()> {
if value == 0 {
return Err(TmslError::InvalidData(format!("{field} must be > 0")));
}
Ok(())
}
pub(crate) fn validate_compress_level(compress_level: u8) -> Result<()> {
if compress_level > 9 {
return Err(TmslError::InvalidData(format!(
"compress_level must be <= 9, got {compress_level}"
)));
}
Ok(())
}
pub(crate) fn validate_index_continuous(index_continuous: u8) -> Result<()> {
if index_continuous > 1 {
return Err(TmslError::InvalidData(format!(
"index_continuous must be 0 or 1, got {index_continuous}"
)));
}
Ok(())
}
pub(crate) fn validate_retention_window(retention_window: u64) -> Result<()> {
if retention_window > i64::MAX as u64 {
return Err(TmslError::InvalidData(format!(
"retention_window must be <= i64::MAX, got {retention_window}"
)));
}
Ok(())
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn validate_dataset_config_values(
data_segment_size: u64,
index_segment_size: u64,
compress_level: u8,
compress_type: u8,
index_continuous: u8,
initial_data_segment_size: u64,
initial_index_segment_size: u64,
retention_window: u64,
) -> Result<()> {
validate_nonzero_size("data_segment_size", data_segment_size)?;
validate_nonzero_size("index_segment_size", index_segment_size)?;
validate_nonzero_size("initial_data_segment_size", initial_data_segment_size)?;
validate_nonzero_size("initial_index_segment_size", initial_index_segment_size)?;
if initial_data_segment_size > data_segment_size {
return Err(TmslError::InvalidData(format!(
"initial_data_segment_size must be <= data_segment_size, got {initial_data_segment_size} > {data_segment_size}"
)));
}
if initial_index_segment_size > index_segment_size {
return Err(TmslError::InvalidData(format!(
"initial_index_segment_size must be <= index_segment_size, got {initial_index_segment_size} > {index_segment_size}"
)));
}
validate_compress_level(compress_level)?;
crate::compress::validate_compress_type(compress_type)?;
validate_index_continuous(index_continuous)?;
validate_retention_window(retention_window)?;
Ok(())
}
#[derive(Clone, Debug)]
pub struct StoreConfig {
pub(crate) flush_interval: Duration,
pub(crate) idle_timeout: Duration,
pub(crate) data_segment_size: u64,
pub(crate) index_segment_size: u64,
pub(crate) initial_data_segment_size: u64,
pub(crate) initial_index_segment_size: u64,
pub(crate) compress_level: u8,
pub(crate) compress_type: u8,
pub(crate) cache_max_memory: usize,
pub(crate) cache_idle_timeout: Duration,
pub(crate) retention_check_hour: u8,
pub(crate) enable_background_thread: bool,
pub(crate) enable_journal: bool,
pub(crate) read_only: Option<bool>,
}
impl Default for StoreConfig {
fn default() -> Self {
Self {
flush_interval: Duration::from_secs(15),
idle_timeout: Duration::from_secs(1800), data_segment_size: 64 * 1024 * 1024, index_segment_size: 4 * 1024 * 1024, initial_data_segment_size: 256 * 1024, initial_index_segment_size: 4 * 1024, compress_level: 6,
compress_type: COMPRESS_TYPE_ZSTD,
cache_max_memory: 256 * 1024 * 1024, cache_idle_timeout: Duration::from_secs(1800), retention_check_hour: 0, enable_background_thread: true, enable_journal: true, read_only: None, }
}
}
impl StoreConfig {
pub fn builder() -> StoreConfigBuilder {
StoreConfigBuilder::default()
}
pub fn flush_interval(&self) -> Duration {
self.flush_interval
}
pub fn idle_timeout(&self) -> Duration {
self.idle_timeout
}
pub fn data_segment_size(&self) -> u64 {
self.data_segment_size
}
pub fn index_segment_size(&self) -> u64 {
self.index_segment_size
}
pub fn initial_data_segment_size(&self) -> u64 {
self.initial_data_segment_size
}
pub fn initial_index_segment_size(&self) -> u64 {
self.initial_index_segment_size
}
pub fn compress_level(&self) -> u8 {
self.compress_level
}
pub fn compress_type(&self) -> u8 {
self.compress_type
}
pub fn cache_max_memory(&self) -> usize {
self.cache_max_memory
}
pub fn cache_idle_timeout(&self) -> Duration {
self.cache_idle_timeout
}
pub fn retention_check_hour(&self) -> u8 {
self.retention_check_hour
}
pub fn enable_background_thread(&self) -> bool {
self.enable_background_thread
}
pub fn enable_journal(&self) -> bool {
self.enable_journal
}
pub fn read_only(&self) -> Option<bool> {
self.read_only
}
pub(crate) fn validate(&self) -> Result<()> {
validate_dataset_config_values(
self.data_segment_size,
self.index_segment_size,
self.compress_level,
self.compress_type,
0,
self.initial_data_segment_size,
self.initial_index_segment_size,
0,
)?;
if self.retention_check_hour > 23 {
return Err(TmslError::InvalidData(format!(
"retention_check_hour must be <= 23, got {}",
self.retention_check_hour
)));
}
Ok(())
}
}
#[derive(Clone, Debug, Default)]
pub struct StoreConfigBuilder {
flush_interval: Option<Duration>,
idle_timeout: Option<Duration>,
data_segment_size: Option<u64>,
index_segment_size: Option<u64>,
initial_data_segment_size: Option<u64>,
initial_index_segment_size: Option<u64>,
compress_level: Option<u8>,
compress_type: Option<u8>,
cache_max_memory: Option<usize>,
cache_idle_timeout: Option<Duration>,
retention_check_hour: Option<u8>,
enable_background_thread: Option<bool>,
enable_journal: Option<bool>,
read_only: Option<Option<bool>>,
}
impl StoreConfigBuilder {
pub fn flush_interval(mut self, interval: Duration) -> Self {
self.flush_interval = Some(interval);
self
}
pub fn idle_timeout(mut self, timeout: Duration) -> Self {
self.idle_timeout = Some(timeout);
self
}
pub fn data_segment_size(mut self, size: u64) -> Self {
self.data_segment_size = Some(size);
self
}
pub fn index_segment_size(mut self, size: u64) -> Self {
self.index_segment_size = Some(size);
self
}
pub fn initial_data_segment_size(mut self, size: u64) -> Self {
self.initial_data_segment_size = Some(size);
self
}
pub fn initial_index_segment_size(mut self, size: u64) -> Self {
self.initial_index_segment_size = Some(size);
self
}
pub fn compress_level(mut self, level: u8) -> Self {
self.compress_level = Some(level.min(9));
self
}
pub fn compress_type(mut self, compress_type: u8) -> Self {
self.compress_type = Some(compress_type);
self
}
pub fn cache_max_memory(mut self, size: usize) -> Self {
self.cache_max_memory = Some(size);
self
}
pub fn cache_idle_timeout(mut self, timeout: Duration) -> Self {
self.cache_idle_timeout = Some(timeout);
self
}
pub fn retention_check_hour(mut self, hour: u8) -> Self {
self.retention_check_hour = Some(hour.clamp(0, 23));
self
}
pub fn enable_background_thread(mut self, enable: bool) -> Self {
self.enable_background_thread = Some(enable);
self
}
pub fn enable_journal(mut self, enable: bool) -> Self {
self.enable_journal = Some(enable);
self
}
pub fn read_only(mut self, read_only: Option<bool>) -> Self {
self.read_only = Some(read_only);
self
}
pub fn build(self) -> StoreConfig {
let defaults = StoreConfig::default();
StoreConfig {
flush_interval: self.flush_interval.unwrap_or(defaults.flush_interval),
idle_timeout: self.idle_timeout.unwrap_or(defaults.idle_timeout),
data_segment_size: self.data_segment_size.unwrap_or(defaults.data_segment_size),
index_segment_size: self
.index_segment_size
.unwrap_or(defaults.index_segment_size),
initial_data_segment_size: self
.initial_data_segment_size
.unwrap_or(defaults.initial_data_segment_size),
initial_index_segment_size: self
.initial_index_segment_size
.unwrap_or(defaults.initial_index_segment_size),
compress_level: self.compress_level.unwrap_or(defaults.compress_level),
compress_type: self.compress_type.unwrap_or(defaults.compress_type),
cache_max_memory: self.cache_max_memory.unwrap_or(defaults.cache_max_memory),
cache_idle_timeout: self
.cache_idle_timeout
.unwrap_or(defaults.cache_idle_timeout),
retention_check_hour: self
.retention_check_hour
.unwrap_or(defaults.retention_check_hour),
enable_background_thread: self
.enable_background_thread
.unwrap_or(defaults.enable_background_thread),
enable_journal: self.enable_journal.unwrap_or(defaults.enable_journal),
read_only: self.read_only.unwrap_or(defaults.read_only),
}
}
}
#[derive(Clone, Debug)]
pub struct DataSetConfig {
pub(crate) data_segment_size: u64,
pub(crate) index_segment_size: u64,
pub(crate) compress_level: u8,
pub(crate) compress_type: u8,
pub(crate) index_continuous: u8,
pub(crate) initial_data_segment_size: u64,
pub(crate) initial_index_segment_size: u64,
pub(crate) retention_window: u64,
pub(crate) enable_journal: bool,
pub(crate) create_time: i64,
}
#[allow(dead_code)]
impl DataSetConfig {
pub fn from_store(config: &StoreConfig) -> Self {
Self {
data_segment_size: config.data_segment_size,
index_segment_size: config.index_segment_size,
compress_level: config.compress_level,
compress_type: config.compress_type,
index_continuous: 0,
initial_data_segment_size: config.initial_data_segment_size,
initial_index_segment_size: config.initial_index_segment_size,
retention_window: 0,
enable_journal: true,
create_time: 0,
}
}
pub fn builder() -> DataSetConfigBuilder {
DataSetConfigBuilder::default()
}
pub fn data_segment_size(&self) -> u64 {
self.data_segment_size
}
pub fn index_segment_size(&self) -> u64 {
self.index_segment_size
}
pub fn compress_level(&self) -> u8 {
self.compress_level
}
pub fn compress_type(&self) -> u8 {
self.compress_type
}
pub fn index_continuous(&self) -> u8 {
self.index_continuous
}
pub fn initial_data_segment_size(&self) -> u64 {
self.initial_data_segment_size
}
pub fn initial_index_segment_size(&self) -> u64 {
self.initial_index_segment_size
}
pub fn retention_window(&self) -> u64 {
self.retention_window
}
pub fn enable_journal(&self) -> bool {
self.enable_journal
}
pub fn create_time(&self) -> i64 {
self.create_time
}
pub(crate) fn validate(&self) -> Result<()> {
validate_dataset_config_values(
self.data_segment_size,
self.index_segment_size,
self.compress_level,
self.compress_type,
self.index_continuous,
self.initial_data_segment_size,
self.initial_index_segment_size,
self.retention_window,
)
}
}
#[derive(Clone, Debug, Default)]
pub struct DataSetConfigBuilder {
data_segment_size: Option<u64>,
index_segment_size: Option<u64>,
compress_level: Option<u8>,
compress_type: Option<u8>,
index_continuous: Option<u8>,
initial_data_segment_size: Option<u64>,
initial_index_segment_size: Option<u64>,
retention_window: Option<u64>,
enable_journal: Option<bool>,
}
impl DataSetConfigBuilder {
pub fn from_store(store: &StoreConfig) -> Self {
Self {
data_segment_size: Some(store.data_segment_size),
index_segment_size: Some(store.index_segment_size),
compress_level: Some(store.compress_level),
compress_type: Some(store.compress_type),
index_continuous: Some(0),
initial_data_segment_size: Some(store.initial_data_segment_size),
initial_index_segment_size: Some(store.initial_index_segment_size),
retention_window: Some(0),
enable_journal: Some(true),
}
}
pub fn data_segment_size(mut self, size: u64) -> Self {
self.data_segment_size = Some(size);
self
}
pub fn index_segment_size(mut self, size: u64) -> Self {
self.index_segment_size = Some(size);
self
}
pub fn compress_level(mut self, level: u8) -> Self {
self.compress_level = Some(level.min(9));
self
}
pub fn compress_type(mut self, compress_type: u8) -> Self {
self.compress_type = Some(compress_type);
self
}
pub fn index_continuous(mut self, value: u8) -> Self {
self.index_continuous = Some(value.clamp(0, 1));
self
}
pub fn initial_data_segment_size(mut self, size: u64) -> Self {
self.initial_data_segment_size = Some(size);
self
}
pub fn initial_index_segment_size(mut self, size: u64) -> Self {
self.initial_index_segment_size = Some(size);
self
}
pub fn retention_window(mut self, units: u64) -> Self {
self.retention_window = Some(units);
self
}
pub fn enable_journal(mut self, enable: bool) -> Self {
self.enable_journal = Some(enable);
self
}
pub fn build(self) -> Result<DataSetConfig> {
let defaults = DataSetConfig::from_store(&StoreConfig::default());
let retention_window = self.retention_window.unwrap_or(0);
validate_retention_window(retention_window)?;
let config = DataSetConfig {
data_segment_size: self.data_segment_size.unwrap_or(defaults.data_segment_size),
index_segment_size: self
.index_segment_size
.unwrap_or(defaults.index_segment_size),
compress_level: self.compress_level.unwrap_or(defaults.compress_level),
compress_type: self.compress_type.unwrap_or(defaults.compress_type),
index_continuous: self.index_continuous.unwrap_or(0),
initial_data_segment_size: self
.initial_data_segment_size
.unwrap_or(defaults.initial_data_segment_size),
initial_index_segment_size: self
.initial_index_segment_size
.unwrap_or(defaults.initial_index_segment_size),
retention_window,
enable_journal: self.enable_journal.unwrap_or(true),
create_time: 0, };
config.validate()?;
Ok(config)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_default_config() {
let cfg = StoreConfig::default();
assert_eq!(cfg.flush_interval, Duration::from_secs(15));
assert_eq!(cfg.idle_timeout, Duration::from_secs(1800));
assert_eq!(cfg.data_segment_size, 64 * 1024 * 1024);
assert_eq!(cfg.index_segment_size, 4 * 1024 * 1024);
assert_eq!(cfg.initial_data_segment_size, 256 * 1024);
assert_eq!(cfg.initial_index_segment_size, 4 * 1024);
assert_eq!(cfg.compress_level, 6);
assert_eq!(cfg.compress_type, crate::compress::COMPRESS_TYPE_ZSTD);
assert_eq!(cfg.cache_max_memory, 256 * 1024 * 1024);
assert_eq!(cfg.cache_idle_timeout, Duration::from_secs(1800));
assert_eq!(cfg.retention_check_hour, 0);
assert!(cfg.enable_background_thread);
assert!(cfg.enable_journal);
}
#[test]
fn test_builder_all_fields() {
let cfg = StoreConfig::builder()
.flush_interval(Duration::from_secs(1200))
.idle_timeout(Duration::from_secs(3600))
.data_segment_size(128 * 1024 * 1024)
.index_segment_size(8 * 1024 * 1024)
.initial_data_segment_size(512 * 1024)
.initial_index_segment_size(8 * 1024)
.compress_level(9)
.cache_max_memory(128 * 1024 * 1024)
.cache_idle_timeout(Duration::from_secs(600))
.retention_check_hour(2)
.enable_journal(false)
.build();
assert_eq!(cfg.flush_interval, Duration::from_secs(1200));
assert_eq!(cfg.idle_timeout, Duration::from_secs(3600));
assert_eq!(cfg.data_segment_size, 128 * 1024 * 1024);
assert_eq!(cfg.index_segment_size, 8 * 1024 * 1024);
assert_eq!(cfg.initial_data_segment_size, 512 * 1024);
assert_eq!(cfg.initial_index_segment_size, 8 * 1024);
assert_eq!(cfg.compress_level, 9);
assert_eq!(cfg.cache_max_memory, 128 * 1024 * 1024);
assert_eq!(cfg.cache_idle_timeout, Duration::from_secs(600));
assert_eq!(cfg.retention_check_hour, 2);
assert!(!cfg.enable_journal);
}
#[test]
fn test_builder_partial() {
let cfg = StoreConfig::builder()
.flush_interval(Duration::from_secs(300))
.build();
let defaults = StoreConfig::default();
assert_eq!(cfg.flush_interval, Duration::from_secs(300));
assert_eq!(cfg.idle_timeout, defaults.idle_timeout);
assert_eq!(cfg.retention_check_hour, defaults.retention_check_hour);
}
#[test]
fn test_builder_compress_level_cap() {
let cfg = StoreConfig::builder().compress_level(15).build();
assert_eq!(cfg.compress_level, 9); }
#[test]
fn test_builder_retention_check_hour_clamp() {
let cfg = StoreConfig::builder().retention_check_hour(99).build();
assert_eq!(cfg.retention_check_hour, 23);
let cfg2 = StoreConfig::builder().retention_check_hour(12).build();
assert_eq!(cfg2.retention_check_hour, 12);
}
#[test]
fn test_builder_disable_background_thread() {
let cfg = StoreConfig::builder()
.enable_background_thread(false)
.build();
assert!(!cfg.enable_background_thread);
let default = StoreConfig::default();
assert!(default.enable_background_thread);
}
#[test]
fn test_builder_disable_journal() {
let cfg = StoreConfig::builder().enable_journal(false).build();
assert!(!cfg.enable_journal);
assert!(StoreConfig::default().enable_journal);
}
#[test]
fn test_dataset_config_from_store() {
let store = StoreConfig::builder()
.data_segment_size(32 * 1024 * 1024)
.compress_level(3)
.build();
let dataset = DataSetConfig::from_store(&store);
assert_eq!(dataset.data_segment_size, 32 * 1024 * 1024);
assert_eq!(dataset.compress_level, 3);
assert_eq!(dataset.retention_window, 0);
assert!(dataset.enable_journal);
}
#[test]
fn test_dataset_config_builder_from_store() {
let store = StoreConfig::builder()
.data_segment_size(32 * 1024 * 1024)
.index_segment_size(8 * 1024 * 1024)
.compress_level(3)
.initial_data_segment_size(512 * 1024)
.initial_index_segment_size(8 * 1024)
.build();
let config = DataSetConfigBuilder::from_store(&store).build().unwrap();
assert_eq!(config.data_segment_size, 32 * 1024 * 1024);
assert_eq!(config.index_segment_size, 8 * 1024 * 1024);
assert_eq!(config.compress_level, 3);
assert_eq!(config.index_continuous, 0);
assert_eq!(config.initial_data_segment_size, 512 * 1024);
assert_eq!(config.initial_index_segment_size, 8 * 1024);
assert_eq!(config.retention_window, 0);
assert!(config.enable_journal);
}
#[test]
fn test_dataset_config_builder_from_store_with_overrides() {
let store = StoreConfig::builder()
.data_segment_size(64 * 1024 * 1024)
.compress_level(6)
.build();
let config = DataSetConfigBuilder::from_store(&store)
.compress_level(9)
.index_continuous(1)
.retention_window(30 * 86400)
.enable_journal(false)
.build()
.unwrap();
assert_eq!(config.compress_level, 9);
assert_eq!(config.index_continuous, 1);
assert_eq!(config.retention_window, 30 * 86400);
assert!(!config.enable_journal);
assert_eq!(config.data_segment_size, 64 * 1024 * 1024);
}
#[test]
fn test_dataset_config_builder_retention_window() {
let config = DataSetConfigBuilder::default()
.retention_window(30)
.build()
.unwrap();
assert_eq!(config.retention_window, 30);
}
#[test]
fn test_dataset_config_builder_rejects_retention_above_i64_max() {
let result = DataSetConfigBuilder::default()
.retention_window(i64::MAX as u64 + 1)
.build();
assert!(result.is_err());
}
}