use std::collections::HashMap;
use std::ffi::{CStr, CString};
use std::os::raw::{c_char, c_int, c_longlong, c_uchar, c_void};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use std::time::Duration;
use crate::bg::TickResult;
use crate::compress::validate_compress_type;
use crate::config::{validate_retention_window, DataSetConfigBuilder, StoreConfig};
use crate::error::TmslError;
use crate::index::segment::IndexEntry;
use crate::journal::{JournalQueue, JournalQueueConsumer};
use crate::queue::{DatasetQueue, DatasetQueueConsumer, QueueConsumerConfig, QueuePollCallback};
use crate::store::{DataSetHandle, Store};
use std::sync::LazyLock;
static NEXT_QUEUE_ID: AtomicUsize = AtomicUsize::new(1);
static QUEUE_REGISTRY: LazyLock<Mutex<HashMap<usize, FfiQueueEntry>>> =
LazyLock::new(|| Mutex::new(HashMap::new()));
static NEXT_CONSUMER_ID: AtomicUsize = AtomicUsize::new(1);
static CONSUMER_REGISTRY: LazyLock<Mutex<HashMap<usize, FfiConsumerEntry>>> =
LazyLock::new(|| Mutex::new(HashMap::new()));
pub type TmslQueuePollCallback = Option<extern "C" fn(userdata: *mut c_void)>;
pub fn write_error(buf: *mut c_char, len: usize, msg: &str) {
if buf.is_null() || len == 0 {
return;
}
let c_str = match CString::new(msg) {
Ok(s) => s,
Err(_) => CString::new("unknown error").unwrap(),
};
let bytes = c_str.as_bytes_with_nul();
let copy_len = bytes.len().min(len - 1);
unsafe {
std::ptr::copy_nonoverlapping(bytes.as_ptr(), buf as *mut u8, copy_len);
*(buf.add(copy_len)) = 0;
}
}
macro_rules! ffi_catch_int {
($err_buf:expr, $err_len:expr, $body:expr) => {
match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| $body)) {
Ok(Ok(val)) => val,
Ok(Err(e)) => {
write_error($err_buf, $err_len, &format!("{}", e));
return -1;
}
Err(_) => {
write_error($err_buf, $err_len, "internal panic");
return -1;
}
}
};
}
macro_rules! ffi_catch_ptr {
($err_buf:expr, $err_len:expr, $body:expr) => {
match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| $body)) {
Ok(Ok(val)) => val,
Ok(Err(e)) => {
write_error($err_buf, $err_len, &format!("{}", e));
return std::ptr::null_mut();
}
Err(_) => {
write_error($err_buf, $err_len, "internal panic");
return std::ptr::null_mut();
}
}
};
}
macro_rules! ffi_catch_usize {
($err_buf:expr, $err_len:expr, $body:expr) => {
match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| $body)) {
Ok(Ok(val)) => val,
Ok(Err(e)) => {
write_error($err_buf, $err_len, &format!("{}", e));
return 0;
}
Err(_) => {
write_error($err_buf, $err_len, "internal panic");
return 0;
}
}
};
}
pub const TMSL_STORE_CONFIG_FFI_VERSION: u32 = 5;
pub const TMSL_DATASET_CONFIG_FFI_VERSION: u32 = 3;
pub const TMSL_QUEUE_CONSUMER_CONFIG_FFI_VERSION: u32 = 1;
pub const TMSL_STORE_READ_ONLY_AUTO: u8 = 0;
pub const TMSL_STORE_READ_ONLY_FALSE: u8 = 1;
pub const TMSL_STORE_READ_ONLY_TRUE: u8 = 2;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct TmslLengthEntry {
pub timestamp: i64,
pub data_len: u32,
}
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct TmslStoreConfigFFI {
pub version: u32,
pub flush_interval_ms: u64,
pub idle_timeout_ms: u64,
pub data_segment_size: u64,
pub index_segment_size: u64,
pub initial_data_segment_size: u64,
pub initial_index_segment_size: u64,
pub cache_max_memory: u64,
pub cache_idle_timeout_ms: u64,
pub compress_level: u8,
pub compress_type: u8,
pub retention_check_hour: u8,
pub enable_background_thread: u8,
pub enable_journal: u8,
pub read_only_mode: u8,
}
impl Default for TmslStoreConfigFFI {
fn default() -> Self {
store_config_to_ffi(&StoreConfig::default())
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct TmslDatasetConfigFFI {
pub version: u32,
pub data_segment_size: u64,
pub index_segment_size: u64,
pub initial_data_segment_size: u64,
pub initial_index_segment_size: u64,
pub retention_window: u64,
pub compress_level: u8,
pub compress_type: u8,
pub index_continuous: u8,
pub enable_journal: u8,
}
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct TmslQueueConsumerConfigFFI {
pub version: u32,
pub running_expired_seconds: u32,
pub max_retry_count: u32,
}
impl Default for TmslQueueConsumerConfigFFI {
fn default() -> Self {
let config = QueueConsumerConfig::default();
Self {
version: TMSL_QUEUE_CONSUMER_CONFIG_FFI_VERSION,
running_expired_seconds: config.running_expired_seconds as u32,
max_retry_count: config.max_retry_count as u32,
}
}
}
struct FfiStoreState {
child_handles: AtomicUsize,
}
impl FfiStoreState {
fn new() -> Self {
Self {
child_handles: AtomicUsize::new(0),
}
}
}
struct FfiStore {
inner: Arc<Mutex<Store>>,
state: Arc<FfiStoreState>,
}
struct FfiDataset {
store: Arc<Mutex<Store>>,
handle: DataSetHandle,
state: Arc<FfiStoreState>,
iterator_count: Arc<AtomicUsize>,
}
struct FfiIterator {
store: Arc<Mutex<Store>>,
handle: DataSetHandle,
state: Arc<FfiStoreState>,
dataset_iterator_count: Arc<AtomicUsize>,
entries: Vec<IndexEntry>,
position: usize,
}
struct FfiJournalIterator {
state: Arc<FfiStoreState>,
entries: Vec<(i64, Vec<u8>)>,
position: usize,
}
#[derive(Clone)]
enum FfiQueueKind {
Dataset {
store: Arc<Mutex<Store>>,
handle: DataSetHandle,
queue: DatasetQueue,
},
Journal {
queue: JournalQueue,
},
}
struct FfiQueueEntry {
kind: FfiQueueKind,
state: Arc<FfiStoreState>,
}
#[derive(Clone)]
enum FfiConsumerKind {
Dataset(DatasetQueueConsumer),
Journal(JournalQueueConsumer),
}
struct FfiConsumerEntry {
queue_handle: usize,
group_name: String,
consumer: FfiConsumerKind,
state: Arc<FfiStoreState>,
}
fn store_config_to_ffi(config: &StoreConfig) -> TmslStoreConfigFFI {
TmslStoreConfigFFI {
version: TMSL_STORE_CONFIG_FFI_VERSION,
flush_interval_ms: config.flush_interval.as_millis() as u64,
idle_timeout_ms: config.idle_timeout.as_millis() as u64,
data_segment_size: config.data_segment_size,
index_segment_size: config.index_segment_size,
initial_data_segment_size: config.initial_data_segment_size,
initial_index_segment_size: config.initial_index_segment_size,
cache_max_memory: config.cache_max_memory as u64,
cache_idle_timeout_ms: config.cache_idle_timeout.as_millis() as u64,
compress_level: config.compress_level,
compress_type: config.compress_type,
retention_check_hour: config.retention_check_hour,
enable_background_thread: u8::from(config.enable_background_thread),
enable_journal: u8::from(config.enable_journal),
read_only_mode: match config.read_only {
None => TMSL_STORE_READ_ONLY_AUTO,
Some(false) => TMSL_STORE_READ_ONLY_FALSE,
Some(true) => TMSL_STORE_READ_ONLY_TRUE,
},
}
}
fn store_config_from_ffi(
config_ptr: *const TmslStoreConfigFFI,
) -> crate::error::Result<StoreConfig> {
if config_ptr.is_null() {
return Ok(StoreConfig::default());
}
let raw = unsafe { *config_ptr };
if raw.version != TMSL_STORE_CONFIG_FFI_VERSION {
return Err(TmslError::InvalidData(format!(
"unsupported store config version {}",
raw.version
)));
}
let cache_max_memory = usize::try_from(raw.cache_max_memory)
.map_err(|_| TmslError::InvalidData("cache_max_memory is too large".into()))?;
validate_compress_type(raw.compress_type)?;
let read_only = match raw.read_only_mode {
TMSL_STORE_READ_ONLY_AUTO => None,
TMSL_STORE_READ_ONLY_FALSE => Some(false),
TMSL_STORE_READ_ONLY_TRUE => Some(true),
other => {
return Err(TmslError::InvalidData(format!(
"unsupported store read_only_mode {other}"
)));
}
};
Ok(StoreConfig::builder()
.flush_interval(Duration::from_millis(raw.flush_interval_ms))
.idle_timeout(Duration::from_millis(raw.idle_timeout_ms))
.data_segment_size(raw.data_segment_size)
.index_segment_size(raw.index_segment_size)
.initial_data_segment_size(raw.initial_data_segment_size)
.initial_index_segment_size(raw.initial_index_segment_size)
.compress_level(raw.compress_level)
.compress_type(raw.compress_type)
.cache_max_memory(cache_max_memory)
.cache_idle_timeout(Duration::from_millis(raw.cache_idle_timeout_ms))
.retention_check_hour(raw.retention_check_hour)
.enable_background_thread(raw.enable_background_thread != 0)
.enable_journal(raw.enable_journal != 0)
.read_only(read_only)
.build())
}
fn dataset_config_from_ffi(
store_config: &StoreConfig,
config_ptr: *const TmslDatasetConfigFFI,
) -> crate::error::Result<DataSetConfigBuilder> {
if config_ptr.is_null() {
return Err(TmslError::InvalidData("dataset config is null".into()));
}
let raw = unsafe { *config_ptr };
if raw.version != TMSL_DATASET_CONFIG_FFI_VERSION {
return Err(TmslError::InvalidData(format!(
"unsupported dataset config version {}",
raw.version
)));
}
validate_compress_type(raw.compress_type)?;
validate_retention_window(raw.retention_window)?;
Ok(DataSetConfigBuilder::from_store(store_config)
.data_segment_size(raw.data_segment_size)
.index_segment_size(raw.index_segment_size)
.initial_data_segment_size(raw.initial_data_segment_size)
.initial_index_segment_size(raw.initial_index_segment_size)
.compress_level(raw.compress_level)
.compress_type(raw.compress_type)
.index_continuous(raw.index_continuous)
.enable_journal(raw.enable_journal != 0)
.retention_window(raw.retention_window))
}
fn queue_consumer_config_from_ffi(
config_ptr: *const TmslQueueConsumerConfigFFI,
) -> crate::error::Result<QueueConsumerConfig> {
if config_ptr.is_null() {
return Ok(QueueConsumerConfig::default());
}
let raw = unsafe { *config_ptr };
if raw.version != TMSL_QUEUE_CONSUMER_CONFIG_FFI_VERSION {
return Err(TmslError::InvalidData(format!(
"unsupported queue consumer config version {}",
raw.version
)));
}
QueueConsumerConfig::builder()
.running_expired_seconds(raw.running_expired_seconds as u64)
.max_retry_count(u16::try_from(raw.max_retry_count).map_err(|_| {
TmslError::InvalidData(format!(
"max_retry_count exceeds u16::MAX before queue config validation: {}",
raw.max_retry_count
))
})?)
.build()
}
fn register_dataset_child(ffi_store: &FfiStore, handle: DataSetHandle) -> Box<FfiDataset> {
ffi_store.state.child_handles.fetch_add(1, Ordering::SeqCst);
Box::new(FfiDataset {
store: Arc::clone(&ffi_store.inner),
handle,
state: Arc::clone(&ffi_store.state),
iterator_count: Arc::new(AtomicUsize::new(0)),
})
}
fn dataset_has_queue_handle(handle: DataSetHandle) -> crate::error::Result<bool> {
let registry = QUEUE_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("queue registry mutex poisoned".into()))?;
Ok(registry.values().any(|entry| {
matches!(
&entry.kind,
FfiQueueKind::Dataset { handle: queue_handle, .. } if queue_handle.0 == handle.0
)
}))
}
fn alloc_bytes(data: &[u8]) -> crate::error::Result<*mut c_uchar> {
let len = data.len().max(1);
let ptr = unsafe { libc::malloc(len) as *mut c_uchar };
if ptr.is_null() {
return Err(TmslError::InvalidData("malloc failed".into()));
}
if !data.is_empty() {
unsafe {
std::ptr::copy_nonoverlapping(data.as_ptr(), ptr, data.len());
}
}
Ok(ptr)
}
fn remove_consumers_for_queue(queue_handle: usize) -> crate::error::Result<usize> {
let mut consumers = CONSUMER_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("consumer registry mutex poisoned".into()))?;
let ids: Vec<usize> = consumers
.iter()
.filter_map(|(id, entry)| (entry.queue_handle == queue_handle).then_some(*id))
.collect();
let count = ids.len();
for id in ids {
consumers.remove(&id);
}
Ok(count)
}
fn remove_consumers_for_group(
queue_handle: usize,
group_name: &str,
) -> crate::error::Result<usize> {
let mut consumers = CONSUMER_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("consumer registry mutex poisoned".into()))?;
let ids: Vec<usize> = consumers
.iter()
.filter_map(|(id, entry)| {
(entry.queue_handle == queue_handle && entry.group_name == group_name).then_some(*id)
})
.collect();
let count = ids.len();
for id in ids {
consumers.remove(&id);
}
Ok(count)
}
fn ffi_poll_callback_to_rust(
callback: TmslQueuePollCallback,
userdata: *mut c_void,
) -> Option<QueuePollCallback> {
callback.map(|cb| {
let userdata_value = userdata as usize;
Arc::new(move || cb(userdata_value as *mut c_void)) as QueuePollCallback
})
}
fn set_consumer_poll_callback(
consumer_handle: usize,
callback: TmslQueuePollCallback,
userdata: *mut c_void,
require_journal: bool,
) -> crate::error::Result<()> {
let consumer = {
let registry = CONSUMER_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("consumer registry mutex poisoned".into()))?;
registry
.get(&consumer_handle)
.ok_or_else(|| TmslError::NotFound("consumer handle not found".into()))?
.consumer
.clone()
};
let callback = ffi_poll_callback_to_rust(callback, userdata);
match consumer {
FfiConsumerKind::Dataset(consumer) => {
if require_journal {
return Err(TmslError::InvalidData(
"consumer handle is not journal".into(),
));
}
consumer.poll_callback(callback)
}
FfiConsumerKind::Journal(consumer) => consumer.poll_callback(callback),
}
}
#[no_mangle]
pub extern "C" fn tmsl_store_config_default(
out_config: *mut TmslStoreConfigFFI,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if out_config.is_null() {
return Err(TmslError::InvalidData("out_config is null".into()));
}
unsafe {
*out_config = TmslStoreConfigFFI::default();
}
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_store_open(
data_dir: *const c_char,
err_buf: *mut c_char,
err_buf_len: usize,
) -> *mut c_void {
tmsl_store_open_with_config(data_dir, std::ptr::null(), err_buf, err_buf_len)
}
#[no_mangle]
pub extern "C" fn tmsl_store_open_with_config(
data_dir: *const c_char,
config_ptr: *const TmslStoreConfigFFI,
err_buf: *mut c_char,
err_buf_len: usize,
) -> *mut c_void {
ffi_catch_ptr!(err_buf, err_buf_len, {
if data_dir.is_null() {
return Err(TmslError::InvalidData("data_dir is null".into()));
}
let dir = unsafe { CStr::from_ptr(data_dir) }
.to_str()
.map_err(|e| TmslError::InvalidData(format!("invalid UTF-8: {}", e)))?;
let config = store_config_from_ffi(config_ptr)?;
let store = Store::open(dir, config)
.map_err(|e| TmslError::Io(std::io::Error::other(e.to_string())))?;
let boxed = Box::new(FfiStore {
inner: Arc::new(Mutex::new(store)),
state: Arc::new(FfiStoreState::new()),
});
Ok(Box::into_raw(boxed) as *mut c_void)
})
}
#[no_mangle]
pub extern "C" fn tmsl_store_close(
store: *mut c_void,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if store.is_null() {
return Err(TmslError::InvalidData("store is null".into()));
}
let ffi_store_ref = unsafe { &*(store as *const FfiStore) };
let child_handles = ffi_store_ref.state.child_handles.load(Ordering::SeqCst);
if child_handles != 0 {
return Err(TmslError::InvalidData(format!(
"store has {} outstanding child handle(s)",
child_handles
)));
}
let ffi_store = unsafe { Box::from_raw(store as *mut FfiStore) };
let inner = Arc::try_unwrap(ffi_store.inner)
.map_err(|_| TmslError::InvalidData("store has outstanding references".into()))?
.into_inner()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
inner
.close()
.map_err(|e| TmslError::Io(std::io::Error::other(e.to_string())))?;
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_store_tick_background_tasks(
store: *mut c_void,
out_executed: *mut u32,
out_next_delay_ms: *mut u64,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if store.is_null() || out_executed.is_null() || out_next_delay_ms.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_store = unsafe { &*(store as *const FfiStore) };
let store_inner = ffi_store
.inner
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
let TickResult {
executed_tasks,
next_delay,
} = store_inner
.tick_background_tasks()
.map_err(|e| TmslError::Io(std::io::Error::other(e.to_string())))?;
unsafe {
*out_executed = executed_tasks as u32;
*out_next_delay_ms = next_delay.as_millis() as u64;
}
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_store_next_background_delay(
store: *mut c_void,
out_next_delay_ms: *mut u64,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if store.is_null() || out_next_delay_ms.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_store = unsafe { &*(store as *const FfiStore) };
let store_inner = ffi_store
.inner
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
let delay = store_inner
.next_background_delay()
.map_err(|e| TmslError::Io(std::io::Error::other(e.to_string())))?;
unsafe {
*out_next_delay_ms = delay.as_millis() as u64;
}
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_free_string_array(arr: *mut *mut c_char, count: u32) {
if arr.is_null() {
return;
}
let count = count as usize;
unsafe {
for i in 0..count {
let s = *arr.add(i);
if !s.is_null() {
drop(CString::from_raw(s));
}
}
drop(Vec::from_raw_parts(arr, count, count));
}
}
#[no_mangle]
pub extern "C" fn tmsl_store_get_dataset_names(
store: *mut c_void,
out_names: *mut *mut *mut c_char,
out_count: *mut u32,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if store.is_null() || out_names.is_null() || out_count.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_store = unsafe { &*(store as *const FfiStore) };
let store_inner = ffi_store
.inner
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
let names = store_inner.get_dataset_names()?;
let count = names.len();
let mut c_strings: Vec<*mut c_char> = Vec::with_capacity(count);
for name in names {
let c_str = CString::new(name)
.map_err(|_| TmslError::InvalidData("dataset name contains null byte".into()))?;
c_strings.push(c_str.into_raw());
}
let (ptr, _, _) = c_strings.into_raw_parts();
unsafe {
*out_names = ptr;
*out_count = count as u32;
}
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_store_get_dataset_types(
store: *mut c_void,
name: *const c_char,
out_types: *mut *mut *mut c_char,
out_count: *mut u32,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if store.is_null() || name.is_null() || out_types.is_null() || out_count.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let name_str = unsafe { CStr::from_ptr(name) }
.to_str()
.map_err(|_| TmslError::InvalidData("invalid UTF-8 in name".into()))?;
let ffi_store = unsafe { &*(store as *const FfiStore) };
let store_inner = ffi_store
.inner
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
let types = store_inner.get_dataset_types(name_str)?;
let count = types.len();
let mut c_strings: Vec<*mut c_char> = Vec::with_capacity(count);
for t in types {
let c_str = CString::new(t)
.map_err(|_| TmslError::InvalidData("dataset type contains null byte".into()))?;
c_strings.push(c_str.into_raw());
}
let (ptr, _, _) = c_strings.into_raw_parts();
unsafe {
*out_types = ptr;
*out_count = count as u32;
}
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_create(
store: *mut c_void,
name: *const c_char,
dataset_type: *const c_char,
data_segment_size: u64,
index_segment_size: u64,
compress_level: c_uchar,
index_continuous: c_uchar,
retention_window: u64,
err_buf: *mut c_char,
err_buf_len: usize,
) -> *mut c_void {
ffi_catch_ptr!(err_buf, err_buf_len, {
if store.is_null() || name.is_null() || dataset_type.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_store = unsafe { &*(store as *const FfiStore) };
let name_str = unsafe { CStr::from_ptr(name) }
.to_str()
.map_err(|e| TmslError::InvalidData(format!("invalid name: {}", e)))?;
let type_str = unsafe { CStr::from_ptr(dataset_type) }
.to_str()
.map_err(|e| TmslError::InvalidData(format!("invalid type: {}", e)))?;
let handle = {
let mut store_inner = ffi_store
.inner
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.create_dataset(
name_str,
type_str,
data_segment_size,
index_segment_size,
compress_level,
index_continuous,
retention_window,
)?
};
let boxed = register_dataset_child(ffi_store, handle);
Ok(Box::into_raw(boxed) as *mut c_void)
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_create_with_config(
store: *mut c_void,
name: *const c_char,
dataset_type: *const c_char,
config_ptr: *const TmslDatasetConfigFFI,
err_buf: *mut c_char,
err_buf_len: usize,
) -> *mut c_void {
ffi_catch_ptr!(err_buf, err_buf_len, {
if store.is_null() || name.is_null() || dataset_type.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_store = unsafe { &*(store as *const FfiStore) };
let name_str = unsafe { CStr::from_ptr(name) }
.to_str()
.map_err(|e| TmslError::InvalidData(format!("invalid name: {}", e)))?;
let type_str = unsafe { CStr::from_ptr(dataset_type) }
.to_str()
.map_err(|e| TmslError::InvalidData(format!("invalid type: {}", e)))?;
let handle = {
let mut store_inner = ffi_store
.inner
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
let dataset_config = dataset_config_from_ffi(store_inner.config(), config_ptr)?;
store_inner.create_dataset_with_config(name_str, type_str, Some(dataset_config))?
};
let boxed = register_dataset_child(ffi_store, handle);
Ok(Box::into_raw(boxed) as *mut c_void)
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_open(
store: *mut c_void,
name: *const c_char,
dataset_type: *const c_char,
err_buf: *mut c_char,
err_buf_len: usize,
) -> *mut c_void {
ffi_catch_ptr!(err_buf, err_buf_len, {
if store.is_null() || name.is_null() || dataset_type.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_store = unsafe { &*(store as *const FfiStore) };
let name_str = unsafe { CStr::from_ptr(name) }
.to_str()
.map_err(|e| TmslError::InvalidData(format!("invalid name: {}", e)))?;
let type_str = unsafe { CStr::from_ptr(dataset_type) }
.to_str()
.map_err(|e| TmslError::InvalidData(format!("invalid type: {}", e)))?;
let handle = {
let mut store_inner = ffi_store
.inner
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.open_dataset(name_str, type_str)?
};
let boxed = register_dataset_child(ffi_store, handle);
Ok(Box::into_raw(boxed) as *mut c_void)
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_open_by_identifier(
store: *mut c_void,
identifier: u64,
err_buf: *mut c_char,
err_buf_len: usize,
) -> *mut c_void {
ffi_catch_ptr!(err_buf, err_buf_len, {
if store.is_null() {
return Err(TmslError::InvalidData("store is null".into()));
}
let ffi_store = unsafe { &*(store as *const FfiStore) };
let handle = {
let mut store_inner = ffi_store
.inner
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.open_dataset_by_identifier(identifier)?
};
let boxed = register_dataset_child(ffi_store, handle);
Ok(Box::into_raw(boxed) as *mut c_void)
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_close(
dataset: *mut c_void,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if dataset.is_null() {
return Err(TmslError::InvalidData("dataset is null".into()));
}
let ffi_ds_ref = unsafe { &*(dataset as *const FfiDataset) };
let iterator_count = ffi_ds_ref.iterator_count.load(Ordering::SeqCst);
if iterator_count != 0 {
return Err(TmslError::InvalidData(format!(
"dataset has {} outstanding iterator handle(s)",
iterator_count
)));
}
let mut store_inner = ffi_ds_ref
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
if dataset_has_queue_handle(ffi_ds_ref.handle)? {
return Err(TmslError::InvalidData(
"dataset has outstanding queue handle(s)".into(),
));
}
store_inner
.close_dataset(ffi_ds_ref.handle)
.map_err(|e| TmslError::Io(std::io::Error::other(e.to_string())))?;
let ffi_ds = unsafe { Box::from_raw(dataset as *mut FfiDataset) };
ffi_ds.state.child_handles.fetch_sub(1, Ordering::SeqCst);
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_drop(
store: *mut c_void,
name: *const c_char,
dataset_type: *const c_char,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if store.is_null() || name.is_null() || dataset_type.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_store = unsafe { &*(store as *const FfiStore) };
let child_handles = ffi_store.state.child_handles.load(Ordering::SeqCst);
if child_handles != 0 {
return Err(TmslError::InvalidData(format!(
"cannot drop dataset with {} outstanding child handle(s)",
child_handles
)));
}
let name_str = unsafe { CStr::from_ptr(name) }
.to_str()
.map_err(|e| TmslError::InvalidData(format!("invalid name: {}", e)))?;
let type_str = unsafe { CStr::from_ptr(dataset_type) }
.to_str()
.map_err(|e| TmslError::InvalidData(format!("invalid type: {}", e)))?;
let mut store_inner = ffi_store
.inner
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.drop_dataset_by_name(name_str, type_str)?;
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_flush(
dataset: *mut c_void,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if dataset.is_null() {
return Err(TmslError::InvalidData("dataset is null".into()));
}
let ffi_ds = unsafe { &*(dataset as *const FfiDataset) };
let ds_arc = {
let store_inner = ffi_ds
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.get_dataset(&ffi_ds.handle)?
};
ds_arc.flush()?;
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_latest_timestamp(
dataset: *mut c_void,
out_ts: *mut c_longlong,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if dataset.is_null() || out_ts.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_ds = unsafe { &*(dataset as *const FfiDataset) };
let ds_arc = {
let store_inner = ffi_ds
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.get_dataset(&ffi_ds.handle)?
};
match ds_arc.latest_written_timestamp() {
Some(ts) => {
unsafe { *out_ts = ts as c_longlong };
Ok(0)
}
None => Ok(1),
}
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_identifier(
dataset: *mut c_void,
out_identifier: *mut u64,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if dataset.is_null() || out_identifier.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_ds = unsafe { &*(dataset as *const FfiDataset) };
let identifier = {
let store_inner = ffi_ds
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.dataset_identifier(ffi_ds.handle)?
};
unsafe { *out_identifier = identifier };
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_write(
dataset: *mut c_void,
timestamp: c_longlong,
data: *const c_uchar,
data_len: usize,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if dataset.is_null() || (data.is_null() && data_len > 0) {
return Err(TmslError::InvalidData("null pointer".into()));
}
let data_slice = if data_len == 0 {
&[]
} else {
unsafe { std::slice::from_raw_parts(data, data_len) }
};
let ffi_ds = unsafe { &*(dataset as *const FfiDataset) };
let mut store_inner = ffi_ds
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.write_dataset(ffi_ds.handle, timestamp, data_slice)?;
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_append(
dataset: *mut c_void,
timestamp: c_longlong,
data: *const c_uchar,
data_len: usize,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if dataset.is_null() || (data.is_null() && data_len > 0) {
return Err(TmslError::InvalidData("null pointer".into()));
}
let data_slice = if data_len == 0 {
&[]
} else {
unsafe { std::slice::from_raw_parts(data, data_len) }
};
let ffi_ds = unsafe { &*(dataset as *const FfiDataset) };
let mut store_inner = ffi_ds
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.append_dataset(ffi_ds.handle, timestamp, data_slice)?;
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_delete(
dataset: *mut c_void,
timestamp: c_longlong,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if dataset.is_null() {
return Err(TmslError::InvalidData("dataset is null".into()));
}
let ffi_ds = unsafe { &*(dataset as *const FfiDataset) };
let mut store_inner = ffi_ds
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.delete_dataset_record(ffi_ds.handle, timestamp)?;
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_read(
dataset: *mut c_void,
timestamp: c_longlong,
out_ts: *mut c_longlong,
out_data: *mut *mut c_uchar,
out_data_len: *mut usize,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if dataset.is_null() || out_ts.is_null() || out_data.is_null() || out_data_len.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_ds = unsafe { &*(dataset as *const FfiDataset) };
let ds_arc = {
let store_inner = ffi_ds
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.get_dataset(&ffi_ds.handle)?
};
match ds_arc.read(timestamp)? {
Some((ts, data)) => {
unsafe { *out_ts = ts as c_longlong };
let ptr = unsafe { libc::malloc(data.len()) as *mut c_uchar };
if ptr.is_null() {
return Err(TmslError::InvalidData("malloc failed".into()));
}
unsafe {
std::ptr::copy_nonoverlapping(data.as_ptr(), ptr, data.len());
*out_data = ptr;
*out_data_len = data.len();
}
Ok(0)
}
None => Ok(1),
}
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_read_latest(
dataset: *mut c_void,
out_ts: *mut c_longlong,
out_data: *mut *mut c_uchar,
out_data_len: *mut usize,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if dataset.is_null() || out_ts.is_null() || out_data.is_null() || out_data_len.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_ds = unsafe { &*(dataset as *const FfiDataset) };
let ds_arc = {
let store_inner = ffi_ds
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.get_dataset(&ffi_ds.handle)?
};
match ds_arc.read_latest()? {
Some((ts, data)) => {
unsafe { *out_ts = ts as c_longlong };
let ptr = unsafe { libc::malloc(data.len()) as *mut c_uchar };
if ptr.is_null() {
return Err(TmslError::InvalidData("malloc failed".into()));
}
unsafe {
std::ptr::copy_nonoverlapping(data.as_ptr(), ptr, data.len());
*out_data = ptr;
*out_data_len = data.len();
}
Ok(0)
}
None => Ok(1),
}
})
}
#[no_mangle]
pub extern "C" fn tmsl_iter_close(iter: *mut c_void) {
if !iter.is_null() {
let ffi_iter = unsafe { Box::from_raw(iter as *mut FfiIterator) };
ffi_iter
.dataset_iterator_count
.fetch_sub(1, Ordering::SeqCst);
ffi_iter.state.child_handles.fetch_sub(1, Ordering::SeqCst);
}
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_query(
dataset: *mut c_void,
start_ts: c_longlong,
end_ts: c_longlong,
err_buf: *mut c_char,
err_buf_len: usize,
) -> *mut c_void {
ffi_catch_ptr!(err_buf, err_buf_len, {
if dataset.is_null() {
return Err(TmslError::InvalidData("dataset is null".into()));
}
let ffi_ds = unsafe { &*(dataset as *const FfiDataset) };
let ds_arc = {
let store_inner = ffi_ds
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.get_dataset(&ffi_ds.handle)?
};
let entries = ds_arc.query_index_entries(start_ts, end_ts)?;
ffi_ds.iterator_count.fetch_add(1, Ordering::SeqCst);
ffi_ds.state.child_handles.fetch_add(1, Ordering::SeqCst);
let iter = Box::new(FfiIterator {
store: Arc::clone(&ffi_ds.store),
handle: ffi_ds.handle,
state: Arc::clone(&ffi_ds.state),
dataset_iterator_count: Arc::clone(&ffi_ds.iterator_count),
entries,
position: 0,
});
Ok(Box::into_raw(iter) as *mut c_void)
})
}
#[no_mangle]
pub extern "C" fn tmsl_iter_next(
iter: *mut c_void,
out_ts: *mut c_longlong,
out_data: *mut *mut c_uchar,
out_data_len: *mut usize,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if iter.is_null() || out_ts.is_null() || out_data.is_null() || out_data_len.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_iter = unsafe { &mut *(iter as *mut FfiIterator) };
let entry = loop {
if ffi_iter.position >= ffi_iter.entries.len() {
return Ok(1);
}
let entry = ffi_iter.entries[ffi_iter.position];
ffi_iter.position += 1;
if !entry.is_filler() {
break entry;
}
};
let ds_arc = {
let store_inner = ffi_iter
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.get_dataset(&ffi_iter.handle)?
};
let (ts, data) = ds_arc.read_entry_at_index(&entry)?;
unsafe { *out_ts = ts as c_longlong };
let ptr = unsafe { libc::malloc(data.len()) as *mut c_uchar };
if ptr.is_null() {
return Err(TmslError::InvalidData("malloc failed".into()));
}
unsafe {
std::ptr::copy_nonoverlapping(data.as_ptr(), ptr, data.len());
*out_data = ptr;
*out_data_len = data.len();
}
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_data_free(data: *mut c_void) {
if !data.is_null() {
unsafe { libc::free(data) };
}
}
#[no_mangle]
pub extern "C" fn tmsl_iter_free_data(data: *mut c_uchar) {
tmsl_data_free(data as *mut c_void);
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_read_exist(
dataset: *mut c_void,
timestamp: c_longlong,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if dataset.is_null() {
return Err(TmslError::InvalidData("dataset is null".into()));
}
let ffi_ds = unsafe { &*(dataset as *const FfiDataset) };
let ds_arc = {
let store_inner = ffi_ds
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.get_dataset(&ffi_ds.handle)?
};
let exists = ds_arc.read_exist(timestamp)?;
Ok(if exists { 1 } else { 0 })
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_query_exist(
dataset: *mut c_void,
start_ts: c_longlong,
end_ts: c_longlong,
out_bitmap: *mut *mut c_uchar,
out_bitmap_len: *mut usize,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if dataset.is_null() || out_bitmap.is_null() || out_bitmap_len.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_ds = unsafe { &*(dataset as *const FfiDataset) };
let ds_arc = {
let store_inner = ffi_ds
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.get_dataset(&ffi_ds.handle)?
};
let bitmap = ds_arc.query_exist(start_ts, end_ts)?;
if bitmap.is_empty() {
unsafe {
*out_bitmap = std::ptr::null_mut();
*out_bitmap_len = 0;
}
} else {
let ptr = unsafe { libc::malloc(bitmap.len()) as *mut c_uchar };
if ptr.is_null() {
return Err(TmslError::InvalidData("malloc failed".into()));
}
unsafe {
std::ptr::copy_nonoverlapping(bitmap.as_ptr(), ptr, bitmap.len());
*out_bitmap = ptr;
*out_bitmap_len = bitmap.len();
}
}
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_read_length(
dataset: *mut c_void,
timestamp: c_longlong,
out_len: *mut u32,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if dataset.is_null() || out_len.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_ds = unsafe { &*(dataset as *const FfiDataset) };
let ds_arc = {
let store_inner = ffi_ds
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.get_dataset(&ffi_ds.handle)?
};
match ds_arc.read_length(timestamp)? {
Some(len) => {
unsafe { *out_len = len };
Ok(0)
}
None => Ok(1),
}
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_query_length(
dataset: *mut c_void,
start_ts: c_longlong,
end_ts: c_longlong,
out_array: *mut *mut TmslLengthEntry,
out_array_len: *mut usize,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if dataset.is_null() || out_array.is_null() || out_array_len.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_ds = unsafe { &*(dataset as *const FfiDataset) };
let ds_arc = {
let store_inner = ffi_ds
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.get_dataset(&ffi_ds.handle)?
};
let pairs = ds_arc.query_length(start_ts, end_ts)?;
if pairs.is_empty() {
unsafe {
*out_array = std::ptr::null_mut();
*out_array_len = 0;
}
} else {
let elem_size = std::mem::size_of::<TmslLengthEntry>();
let total_size = pairs.len() * elem_size;
let ptr = unsafe { libc::malloc(total_size) as *mut TmslLengthEntry };
if ptr.is_null() {
return Err(TmslError::InvalidData("malloc failed".into()));
}
for (i, (ts, len)) in pairs.iter().enumerate() {
unsafe {
ptr.add(i).write(TmslLengthEntry {
timestamp: *ts,
data_len: *len,
});
}
}
unsafe {
*out_array = ptr;
*out_array_len = pairs.len();
}
}
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_dataset_query_length_iter(
dataset: *mut c_void,
start_ts: c_longlong,
end_ts: c_longlong,
err_buf: *mut c_char,
err_buf_len: usize,
) -> *mut c_void {
ffi_catch_ptr!(err_buf, err_buf_len, {
if dataset.is_null() {
return Err(TmslError::InvalidData("dataset is null".into()));
}
let ffi_ds = unsafe { &*(dataset as *const FfiDataset) };
let ds_arc = {
let store_inner = ffi_ds
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store_inner.get_dataset(&ffi_ds.handle)?
};
let entries = ds_arc.query_index_entries(start_ts, end_ts)?;
let ffi_iter = Box::new(FfiIterator {
store: Arc::clone(&ffi_ds.store),
handle: ffi_ds.handle,
state: Arc::clone(&ffi_ds.state),
dataset_iterator_count: Arc::clone(&ffi_ds.iterator_count),
entries,
position: 0,
});
ffi_ds.iterator_count.fetch_add(1, Ordering::SeqCst);
ffi_ds.state.child_handles.fetch_add(1, Ordering::SeqCst);
Ok(Box::into_raw(ffi_iter) as *mut c_void)
})
}
#[no_mangle]
pub extern "C" fn tmsl_length_iter_next(
iter: *mut c_void,
out_ts: *mut c_longlong,
out_len: *mut u32,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if iter.is_null() || out_ts.is_null() || out_len.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_iter = unsafe { &mut *(iter as *mut FfiIterator) };
loop {
if ffi_iter.position >= ffi_iter.entries.len() {
return Ok(1);
}
let entry = &ffi_iter.entries[ffi_iter.position];
ffi_iter.position += 1;
if entry.block_offset == crate::index::segment::BLOCK_OFFSET_FILLER {
continue;
}
let store = ffi_iter
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
let ds_arc = store.get_dataset(&ffi_iter.handle)?;
let data_len = ds_arc.read_record_data_len_at_index(entry)?;
unsafe {
*out_ts = entry.timestamp as c_longlong;
*out_len = data_len;
}
return Ok(0);
}
})
}
#[no_mangle]
pub extern "C" fn tmsl_queue_open(
dataset: *mut c_void,
err_buf: *mut c_char,
err_len: usize,
) -> usize {
ffi_catch_usize! { err_buf, err_len, {
if dataset.is_null() {
return Err(TmslError::InvalidData("dataset is null".into()));
}
let ffi_ds = unsafe { &*(dataset as *const FfiDataset) };
let id = NEXT_QUEUE_ID.fetch_add(1, Ordering::Relaxed);
{
let mut store = ffi_ds
.store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
let queue = store.open_queue(ffi_ds.handle)?;
ffi_ds.state.child_handles.fetch_add(1, Ordering::SeqCst);
QUEUE_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("queue registry mutex poisoned".into()))?
.insert(
id,
FfiQueueEntry {
kind: FfiQueueKind::Dataset {
store: Arc::clone(&ffi_ds.store),
handle: ffi_ds.handle,
queue,
},
state: Arc::clone(&ffi_ds.state),
},
);
}
Ok::<usize, TmslError>(id)
}}
}
#[no_mangle]
pub extern "C" fn tmsl_queue_close(
queue_handle: usize,
err_buf: *mut c_char,
err_len: usize,
) -> c_int {
ffi_catch_int! { err_buf, err_len, {
let (kind, state) = {
let registry = QUEUE_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("queue registry mutex poisoned".into()))?;
let entry = registry.get(&queue_handle).ok_or_else(|| {
TmslError::NotFound("queue handle not found".into())
})?;
(
entry.kind.clone(),
Arc::clone(&entry.state),
)
};
match &kind {
FfiQueueKind::Dataset { store, handle, .. } => {
let mut store = store
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store.close_queue(*handle)?;
}
FfiQueueKind::Journal { queue } => {
queue.close()?;
}
}
let removed_consumers = remove_consumers_for_queue(queue_handle)?;
let removed_queue = QUEUE_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("queue registry mutex poisoned".into()))?
.remove(&queue_handle)
.ok_or_else(|| TmslError::NotFound("queue handle not found".into()))?;
drop(removed_queue);
state
.child_handles
.fetch_sub(removed_consumers + 1, Ordering::SeqCst);
Ok::<c_int, TmslError>(0)
}}
}
fn open_queue_consumer_with_config_impl(
queue_handle: usize,
group_name: *const c_char,
config: QueueConsumerConfig,
) -> crate::error::Result<usize> {
if group_name.is_null() {
return Err(TmslError::InvalidData("group_name is null".into()));
}
let group_name = unsafe { CStr::from_ptr(group_name) }
.to_str()
.map_err(|_| TmslError::InvalidData("invalid group name encoding".into()))?;
let (kind, state) = {
let registry = QUEUE_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("queue registry mutex poisoned".into()))?;
let entry = registry
.get(&queue_handle)
.ok_or_else(|| TmslError::NotFound("queue handle not found".into()))?;
(entry.kind.clone(), Arc::clone(&entry.state))
};
let consumer = match kind {
FfiQueueKind::Dataset { queue, .. } => {
FfiConsumerKind::Dataset(queue.open_consumer_with_config(group_name, config)?)
}
FfiQueueKind::Journal { queue } => {
FfiConsumerKind::Journal(queue.open_consumer_with_config(group_name, config)?)
}
};
let id = NEXT_CONSUMER_ID.fetch_add(1, Ordering::Relaxed);
state.child_handles.fetch_add(1, Ordering::SeqCst);
CONSUMER_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("consumer registry mutex poisoned".into()))?
.insert(
id,
FfiConsumerEntry {
queue_handle,
group_name: group_name.to_string(),
consumer,
state,
},
);
Ok(id)
}
#[no_mangle]
pub extern "C" fn tmsl_queue_consumer_open(
queue_handle: usize,
group_name: *const c_char,
err_buf: *mut c_char,
err_len: usize,
) -> usize {
ffi_catch_usize! { err_buf, err_len, {
open_queue_consumer_with_config_impl(
queue_handle,
group_name,
QueueConsumerConfig::default(),
)
}}
}
#[no_mangle]
pub extern "C" fn tmsl_queue_consumer_open_with_config(
queue_handle: usize,
group_name: *const c_char,
config: *const TmslQueueConsumerConfigFFI,
err_buf: *mut c_char,
err_len: usize,
) -> usize {
ffi_catch_usize! { err_buf, err_len, {
let config = queue_consumer_config_from_ffi(config)?;
open_queue_consumer_with_config_impl(queue_handle, group_name, config)
}}
}
#[no_mangle]
pub extern "C" fn tmsl_queue_consumer_drop(
queue_handle: usize,
consumer_handle: usize,
err_buf: *mut c_char,
err_len: usize,
) -> c_int {
ffi_catch_int! { err_buf, err_len, {
let (kind, group_name, state) = {
let consumers = CONSUMER_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("consumer registry mutex poisoned".into()))?;
let consumer = consumers
.get(&consumer_handle)
.ok_or_else(|| TmslError::NotFound("consumer handle not found".into()))?;
if consumer.queue_handle != queue_handle {
return Err(TmslError::InvalidData(
"consumer does not belong to queue handle".into(),
));
}
let registry = QUEUE_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("queue registry mutex poisoned".into()))?;
let kind = registry
.get(&queue_handle)
.ok_or_else(|| TmslError::NotFound("queue handle not found".into()))?
.kind
.clone();
(
kind,
consumer.group_name.clone(),
Arc::clone(&consumer.state),
)
};
match kind {
FfiQueueKind::Dataset { queue, .. } => queue.drop_consumer(&group_name)?,
FfiQueueKind::Journal { .. } => {
return Err(TmslError::InvalidData(
"journal queue consumer groups cannot be dropped through dataset queue API"
.into(),
));
}
}
let removed = remove_consumers_for_group(queue_handle, &group_name)?;
state.child_handles.fetch_sub(removed, Ordering::SeqCst);
Ok::<c_int, TmslError>(0)
}}
}
#[no_mangle]
pub extern "C" fn tmsl_queue_push(
queue_handle: usize,
data: *const c_uchar,
data_len: usize,
err_buf: *mut c_char,
err_len: usize,
) -> c_longlong {
ffi_catch_int! { err_buf, err_len, {
if data.is_null() || data_len == 0 {
return Err(TmslError::InvalidData("data pointer is null or empty".into()));
}
let kind = {
let registry = QUEUE_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("queue registry mutex poisoned".into()))?;
registry
.get(&queue_handle)
.ok_or_else(|| TmslError::NotFound("queue handle not found".into()))?
.kind
.clone()
};
let slice = unsafe { std::slice::from_raw_parts(data, data_len) };
let ts = match kind {
FfiQueueKind::Dataset { queue, .. } => queue.push(slice)?,
FfiQueueKind::Journal { .. } => {
return Err(TmslError::InvalidData("journal queue is read-only".into()));
}
};
Ok::<c_longlong, TmslError>(ts as c_longlong)
}}
}
#[no_mangle]
pub extern "C" fn tmsl_queue_poll(
consumer_handle: usize,
timeout_ms: c_longlong,
out_timestamp: *mut c_longlong,
out_data: *mut *mut c_uchar,
out_len: *mut usize,
err_buf: *mut c_char,
err_len: usize,
) -> c_int {
ffi_catch_int! { err_buf, err_len, {
if out_timestamp.is_null() || out_data.is_null() || out_len.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let consumer = {
let registry = CONSUMER_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("consumer registry mutex poisoned".into()))?;
registry
.get(&consumer_handle)
.ok_or_else(|| TmslError::NotFound("consumer handle not found".into()))?
.consumer
.clone()
};
let timeout = if timeout_ms <= 0 {
Duration::from_millis(0)
} else {
Duration::from_millis(timeout_ms as u64)
};
let polled = match consumer {
FfiConsumerKind::Dataset(consumer) => consumer.poll(timeout)?,
FfiConsumerKind::Journal(consumer) => consumer.poll(timeout)?,
};
match polled {
Some((ts, data)) => {
unsafe {
*out_timestamp = ts as c_longlong;
let ptr = alloc_bytes(&data)?;
*out_data = ptr;
*out_len = data.len();
}
Ok(0)
}
None => Ok(-2), }
}}
}
#[no_mangle]
pub extern "C" fn tmsl_queue_ack(
consumer_handle: usize,
timestamp: c_longlong,
err_buf: *mut c_char,
err_len: usize,
) -> c_int {
ffi_catch_int! { err_buf, err_len, {
let consumer = {
let registry = CONSUMER_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("consumer registry mutex poisoned".into()))?;
registry
.get(&consumer_handle)
.ok_or_else(|| TmslError::NotFound("consumer handle not found".into()))?
.consumer
.clone()
};
match consumer {
FfiConsumerKind::Dataset(consumer) => consumer.ack(timestamp)?,
FfiConsumerKind::Journal(consumer) => consumer.ack(timestamp)?,
}
Ok::<c_int, TmslError>(0)
}}
}
#[no_mangle]
pub extern "C" fn tmsl_queue_consumer_poll_callback(
consumer_handle: usize,
callback: TmslQueuePollCallback,
userdata: *mut c_void,
err_buf: *mut c_char,
err_len: usize,
) -> c_int {
ffi_catch_int! { err_buf, err_len, {
set_consumer_poll_callback(consumer_handle, callback, userdata, false)?;
Ok::<c_int, TmslError>(0)
}}
}
#[no_mangle]
pub extern "C" fn tmsl_journal_latest_sequence(
store: *mut c_void,
out_sequence: *mut c_longlong,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if store.is_null() || out_sequence.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_store = unsafe { &*(store as *const FfiStore) };
let store = ffi_store
.inner
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
let sequence = store.journal_latest_sequence()?.unwrap_or(0);
unsafe {
*out_sequence = sequence as c_longlong;
}
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_journal_read(
store: *mut c_void,
sequence: c_longlong,
out_sequence: *mut c_longlong,
out_data: *mut *mut c_uchar,
out_data_len: *mut usize,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if store.is_null() || out_sequence.is_null() || out_data.is_null() || out_data_len.is_null()
{
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_store = unsafe { &*(store as *const FfiStore) };
let store = ffi_store
.inner
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
match store.journal_read(sequence)? {
Some((seq, data)) => {
let ptr = alloc_bytes(&data)?;
unsafe {
*out_sequence = seq as c_longlong;
*out_data = ptr;
*out_data_len = data.len();
}
Ok(0)
}
None => {
unsafe {
*out_data = std::ptr::null_mut();
*out_data_len = 0;
}
Ok(1)
}
}
})
}
#[no_mangle]
pub extern "C" fn tmsl_journal_query(
store: *mut c_void,
start_sequence: c_longlong,
end_sequence: c_longlong,
err_buf: *mut c_char,
err_buf_len: usize,
) -> *mut c_void {
ffi_catch_ptr!(err_buf, err_buf_len, {
if store.is_null() {
return Err(TmslError::InvalidData("store is null".into()));
}
let ffi_store = unsafe { &*(store as *const FfiStore) };
let entries = {
let store = ffi_store
.inner
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store.journal_query(start_sequence, end_sequence)?
};
ffi_store.state.child_handles.fetch_add(1, Ordering::SeqCst);
let iter = Box::new(FfiJournalIterator {
state: Arc::clone(&ffi_store.state),
entries,
position: 0,
});
Ok(Box::into_raw(iter) as *mut c_void)
})
}
#[no_mangle]
pub extern "C" fn tmsl_journal_iter_next(
iter: *mut c_void,
out_sequence: *mut c_longlong,
out_data: *mut *mut c_uchar,
out_data_len: *mut usize,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if iter.is_null() || out_sequence.is_null() || out_data.is_null() || out_data_len.is_null()
{
return Err(TmslError::InvalidData("null pointer".into()));
}
let ffi_iter = unsafe { &mut *(iter as *mut FfiJournalIterator) };
if ffi_iter.position >= ffi_iter.entries.len() {
return Ok(1);
}
let (sequence, data) = &ffi_iter.entries[ffi_iter.position];
ffi_iter.position += 1;
let ptr = alloc_bytes(data)?;
unsafe {
*out_sequence = *sequence as c_longlong;
*out_data = ptr;
*out_data_len = data.len();
}
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_journal_iter_close(iter: *mut c_void) {
if !iter.is_null() {
let ffi_iter = unsafe { Box::from_raw(iter as *mut FfiJournalIterator) };
ffi_iter.state.child_handles.fetch_sub(1, Ordering::SeqCst);
}
}
#[no_mangle]
pub extern "C" fn tmsl_journal_queue_open(
store: *mut c_void,
err_buf: *mut c_char,
err_buf_len: usize,
) -> usize {
ffi_catch_usize!(err_buf, err_buf_len, {
if store.is_null() {
return Err(TmslError::InvalidData("store is null".into()));
}
let ffi_store = unsafe { &*(store as *const FfiStore) };
let queue = {
let mut store = ffi_store
.inner
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
store.open_journal_queue()?
};
let id = NEXT_QUEUE_ID.fetch_add(1, Ordering::Relaxed);
ffi_store.state.child_handles.fetch_add(1, Ordering::SeqCst);
QUEUE_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("queue registry mutex poisoned".into()))?
.insert(
id,
FfiQueueEntry {
kind: FfiQueueKind::Journal { queue },
state: Arc::clone(&ffi_store.state),
},
);
Ok(id)
})
}
#[no_mangle]
pub extern "C" fn tmsl_journal_queue_close(
queue_handle: usize,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
let (queue, state) = {
let registry = QUEUE_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("queue registry mutex poisoned".into()))?;
let entry = registry
.get(&queue_handle)
.ok_or_else(|| TmslError::NotFound("queue handle not found".into()))?;
match &entry.kind {
FfiQueueKind::Journal { queue } => (queue.clone(), Arc::clone(&entry.state)),
FfiQueueKind::Dataset { .. } => {
return Err(TmslError::InvalidData("queue handle is not journal".into()));
}
}
};
queue.close()?;
let removed_consumers = remove_consumers_for_queue(queue_handle)?;
QUEUE_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("queue registry mutex poisoned".into()))?
.remove(&queue_handle)
.ok_or_else(|| TmslError::NotFound("queue handle not found".into()))?;
state
.child_handles
.fetch_sub(removed_consumers + 1, Ordering::SeqCst);
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_journal_queue_consumer_open(
queue_handle: usize,
group_name: *const c_char,
err_buf: *mut c_char,
err_buf_len: usize,
) -> usize {
tmsl_journal_queue_consumer_open_with_config(
queue_handle,
group_name,
std::ptr::null(),
err_buf,
err_buf_len,
)
}
#[no_mangle]
pub extern "C" fn tmsl_journal_queue_consumer_open_with_config(
queue_handle: usize,
group_name: *const c_char,
config: *const TmslQueueConsumerConfigFFI,
err_buf: *mut c_char,
err_buf_len: usize,
) -> usize {
ffi_catch_usize!(err_buf, err_buf_len, {
{
let registry = QUEUE_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("queue registry mutex poisoned".into()))?;
let entry = registry
.get(&queue_handle)
.ok_or_else(|| TmslError::NotFound("queue handle not found".into()))?;
if !matches!(entry.kind, FfiQueueKind::Journal { .. }) {
return Err(TmslError::InvalidData("queue handle is not journal".into()));
}
}
let config = queue_consumer_config_from_ffi(config)?;
open_queue_consumer_with_config_impl(queue_handle, group_name, config)
})
}
#[no_mangle]
pub extern "C" fn tmsl_journal_queue_consumer_poll_callback(
consumer_handle: usize,
callback: TmslQueuePollCallback,
userdata: *mut c_void,
err_buf: *mut c_char,
err_len: usize,
) -> c_int {
ffi_catch_int! { err_buf, err_len, {
set_consumer_poll_callback(consumer_handle, callback, userdata, true)?;
Ok::<c_int, TmslError>(0)
}}
}
#[no_mangle]
pub extern "C" fn tmsl_journal_queue_poll(
consumer_handle: usize,
timeout_ms: c_longlong,
out_sequence: *mut c_longlong,
out_data: *mut *mut c_uchar,
out_data_len: *mut usize,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if out_sequence.is_null() || out_data.is_null() || out_data_len.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let consumer = {
let registry = CONSUMER_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("consumer registry mutex poisoned".into()))?;
match ®istry
.get(&consumer_handle)
.ok_or_else(|| TmslError::NotFound("consumer handle not found".into()))?
.consumer
{
FfiConsumerKind::Journal(consumer) => consumer.clone(),
FfiConsumerKind::Dataset(_) => {
return Err(TmslError::InvalidData(
"consumer handle is not journal".into(),
));
}
}
};
let timeout = if timeout_ms <= 0 {
Duration::from_millis(0)
} else {
Duration::from_millis(timeout_ms as u64)
};
match consumer.poll(timeout)? {
Some((sequence, data)) => {
let ptr = alloc_bytes(&data)?;
unsafe {
*out_sequence = sequence as c_longlong;
*out_data = ptr;
*out_data_len = data.len();
}
Ok(0)
}
None => Ok(-2),
}
})
}
#[no_mangle]
pub extern "C" fn tmsl_journal_queue_ack(
consumer_handle: usize,
sequence: c_longlong,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
let consumer = {
let registry = CONSUMER_REGISTRY
.lock()
.map_err(|_| TmslError::InvalidData("consumer registry mutex poisoned".into()))?;
match ®istry
.get(&consumer_handle)
.ok_or_else(|| TmslError::NotFound("consumer handle not found".into()))?
.consumer
{
FfiConsumerKind::Journal(consumer) => consumer.clone(),
FfiConsumerKind::Dataset(_) => {
return Err(TmslError::InvalidData(
"consumer handle is not journal".into(),
));
}
}
};
consumer.ack(sequence)?;
Ok(0)
})
}
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct TmslDataSetInfo {
pub name: *mut c_char,
pub dataset_type: *mut c_char,
pub base_dir: *mut c_char,
pub identifier: u64,
pub data_segment_size: u64,
pub index_segment_size: u64,
pub initial_data_segment_size: u64,
pub initial_index_segment_size: u64,
pub compress_type: u8,
pub compress_level: u8,
pub index_continuous: u8,
pub retention_window: u64,
pub enable_journal: u8,
pub create_time: i64,
}
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct TmslDataSetState {
pub has_latest_written_timestamp: u8,
pub latest_written_timestamp: i64,
pub open_data_segments: u32,
pub data_segments: u32,
pub total_record_count: u64,
pub total_data_size: u64,
pub total_uncompressed_size: u64,
pub total_invalid_record_count: u64,
pub has_min_timestamp: u8,
pub min_timestamp: i64,
pub has_max_timestamp: u8,
pub max_timestamp: i64,
pub open_index_segments: u32,
pub index_segments: u32,
pub pending_index_entries: u32,
pub has_base_timestamp: u8,
pub base_timestamp: i64,
pub read_only: u8,
pub has_block_cache: u8,
pub has_journal: u8,
pub has_queue: u8,
pub queue_consumer_groups: u32,
}
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct TmslInspectResult {
pub info: TmslDataSetInfo,
pub state: TmslDataSetState,
}
#[no_mangle]
pub extern "C" fn tmsl_store_inspect_dataset(
store: *mut c_void,
name: *const c_char,
dataset_type: *const c_char,
out_result: *mut TmslInspectResult,
err_buf: *mut c_char,
err_buf_len: usize,
) -> c_int {
ffi_catch_int!(err_buf, err_buf_len, {
if store.is_null() || name.is_null() || dataset_type.is_null() || out_result.is_null() {
return Err(TmslError::InvalidData("null pointer".into()));
}
let name_str = unsafe { CStr::from_ptr(name) }
.to_str()
.map_err(|_| TmslError::InvalidData("invalid UTF-8 in name".into()))?;
let type_str = unsafe { CStr::from_ptr(dataset_type) }
.to_str()
.map_err(|_| TmslError::InvalidData("invalid UTF-8 in dataset_type".into()))?;
let ffi_store = unsafe { &*(store as *const FfiStore) };
let store_inner = ffi_store
.inner
.lock()
.map_err(|_| TmslError::InvalidData("store mutex poisoned".into()))?;
let result = store_inner.inspect_dataset(name_str, type_str)?;
let name_cstr = CString::new(result.info.name)
.map_err(|_| TmslError::InvalidData("name contains null byte".into()))?;
let type_cstr = CString::new(result.info.dataset_type)
.map_err(|_| TmslError::InvalidData("dataset_type contains null byte".into()))?;
let base_dir_cstr = CString::new(result.info.base_dir)
.map_err(|_| TmslError::InvalidData("base_dir contains null byte".into()))?;
let info = TmslDataSetInfo {
name: name_cstr.into_raw(),
dataset_type: type_cstr.into_raw(),
base_dir: base_dir_cstr.into_raw(),
identifier: result.info.identifier,
data_segment_size: result.info.data_segment_size,
index_segment_size: result.info.index_segment_size,
initial_data_segment_size: result.info.initial_data_segment_size,
initial_index_segment_size: result.info.initial_index_segment_size,
compress_type: result.info.compress_type,
compress_level: result.info.compress_level,
index_continuous: result.info.index_continuous,
retention_window: result.info.retention_window,
enable_journal: u8::from(result.info.enable_journal),
create_time: result.info.create_time,
};
let state = TmslDataSetState {
has_latest_written_timestamp: u8::from(result.state.latest_written_timestamp.is_some()),
latest_written_timestamp: result.state.latest_written_timestamp.unwrap_or(0),
open_data_segments: result.state.open_data_segments,
data_segments: result.state.data_segments,
total_record_count: result.state.total_record_count,
total_data_size: result.state.total_data_size,
total_uncompressed_size: result.state.total_uncompressed_size,
total_invalid_record_count: result.state.total_invalid_record_count,
has_min_timestamp: u8::from(result.state.min_timestamp.is_some()),
min_timestamp: result.state.min_timestamp.unwrap_or(0),
has_max_timestamp: u8::from(result.state.max_timestamp.is_some()),
max_timestamp: result.state.max_timestamp.unwrap_or(0),
open_index_segments: result.state.open_index_segments,
index_segments: result.state.index_segments,
pending_index_entries: result.state.pending_index_entries,
has_base_timestamp: u8::from(result.state.base_timestamp.is_some()),
base_timestamp: result.state.base_timestamp.unwrap_or(0),
read_only: u8::from(result.state.read_only),
has_block_cache: u8::from(result.state.has_block_cache),
has_journal: u8::from(result.state.has_journal),
has_queue: u8::from(result.state.has_queue),
queue_consumer_groups: result.state.queue_consumer_groups,
};
unsafe {
*out_result = TmslInspectResult { info, state };
}
Ok(0)
})
}
#[no_mangle]
pub extern "C" fn tmsl_free_inspect_result(result: *mut TmslInspectResult) {
if result.is_null() {
return;
}
unsafe {
let result_ref = &*result;
if !result_ref.info.name.is_null() {
let _ = CString::from_raw(result_ref.info.name);
}
if !result_ref.info.dataset_type.is_null() {
let _ = CString::from_raw(result_ref.info.dataset_type);
}
if !result_ref.info.base_dir.is_null() {
let _ = CString::from_raw(result_ref.info.base_dir);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::ffi::CString;
use std::sync::atomic::{AtomicUsize as TestAtomicUsize, Ordering as TestOrdering};
extern "C" fn ffi_poll_callback(userdata: *mut c_void) {
let hits = unsafe { &*(userdata as *const TestAtomicUsize) };
hits.fetch_add(1, TestOrdering::SeqCst);
}
fn temp_store_dir(name: &str) -> std::path::PathBuf {
let dir = std::env::temp_dir().join("timslite_ffi_test").join(name);
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
dir
}
fn cleanup_store_dir(dir: &std::path::Path) {
let _ = std::fs::remove_dir_all(dir);
}
fn err_buf() -> ([c_char; 256], usize) {
([0; 256], 256)
}
#[test]
fn tmsl_length_entry_layout_matches_c_abi() {
assert_eq!(std::mem::size_of::<TmslLengthEntry>(), 16);
assert_eq!(std::mem::align_of::<TmslLengthEntry>(), 8);
}
#[test]
fn test_store_config_ffi_read_only_modes() {
let (mut err, err_len) = err_buf();
let mut config = TmslStoreConfigFFI::default();
assert_eq!(
tmsl_store_config_default(&mut config, err.as_mut_ptr(), err_len),
0
);
assert_eq!(config.read_only_mode, TMSL_STORE_READ_ONLY_AUTO);
config.read_only_mode = TMSL_STORE_READ_ONLY_TRUE;
assert_eq!(
store_config_from_ffi(&config).unwrap().read_only(),
Some(true)
);
config.read_only_mode = TMSL_STORE_READ_ONLY_FALSE;
assert_eq!(
store_config_from_ffi(&config).unwrap().read_only(),
Some(false)
);
}
#[test]
fn test_store_open_with_config_and_child_lifecycle() {
let dir = temp_store_dir("timslite_ffi_store_config_lifecycle");
let dir_c = CString::new(dir.to_string_lossy().as_bytes()).unwrap();
let (mut err, err_len) = err_buf();
let mut config = TmslStoreConfigFFI::default();
assert_eq!(
tmsl_store_config_default(&mut config, err.as_mut_ptr(), err_len),
0
);
config.enable_background_thread = 0;
let store = tmsl_store_open_with_config(dir_c.as_ptr(), &config, err.as_mut_ptr(), err_len);
assert!(!store.is_null());
let name = CString::new("sensor").unwrap();
let ty = CString::new("wave").unwrap();
let dataset = tmsl_dataset_create(
store,
name.as_ptr(),
ty.as_ptr(),
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
err.as_mut_ptr(),
err_len,
);
assert!(!dataset.is_null());
assert_eq!(
tmsl_store_close(store, err.as_mut_ptr(), err_len),
-1,
"store close must reject outstanding dataset handles"
);
assert_eq!(tmsl_dataset_close(dataset, err.as_mut_ptr(), err_len), 0);
assert_eq!(tmsl_store_close(store, err.as_mut_ptr(), err_len), 0);
cleanup_store_dir(&dir);
}
#[test]
fn test_dataset_identifier_ffi_api() {
let dir = temp_store_dir("timslite_ffi_dataset_identifier");
let dir_c = CString::new(dir.to_string_lossy().as_bytes()).unwrap();
let (mut err, err_len) = err_buf();
let mut config = TmslStoreConfigFFI::default();
assert_eq!(
tmsl_store_config_default(&mut config, err.as_mut_ptr(), err_len),
0
);
config.enable_background_thread = 0;
config.enable_journal = 0;
let store = tmsl_store_open_with_config(dir_c.as_ptr(), &config, err.as_mut_ptr(), err_len);
assert!(!store.is_null());
let name = CString::new("sensor").unwrap();
let ty = CString::new("wave").unwrap();
let dataset = tmsl_dataset_create(
store,
name.as_ptr(),
ty.as_ptr(),
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
err.as_mut_ptr(),
err_len,
);
assert!(!dataset.is_null());
let mut identifier = 0u64;
assert_eq!(
tmsl_dataset_identifier(dataset, &mut identifier, err.as_mut_ptr(), err_len),
0
);
assert_eq!(identifier, 1);
assert_eq!(tmsl_dataset_close(dataset, err.as_mut_ptr(), err_len), 0);
let dataset_by_id =
tmsl_dataset_open_by_identifier(store, identifier, err.as_mut_ptr(), err_len);
assert!(!dataset_by_id.is_null());
assert_eq!(
tmsl_dataset_close(dataset_by_id, err.as_mut_ptr(), err_len),
0
);
assert_eq!(tmsl_store_close(store, err.as_mut_ptr(), err_len), 0);
cleanup_store_dir(&dir);
}
#[test]
fn test_dataset_create_with_config_and_data_free() {
let dir = temp_store_dir("timslite_ffi_dataset_config");
let dir_c = CString::new(dir.to_string_lossy().as_bytes()).unwrap();
let (mut err, err_len) = err_buf();
let mut store_config = TmslStoreConfigFFI::default();
assert_eq!(
tmsl_store_config_default(&mut store_config, err.as_mut_ptr(), err_len),
0
);
store_config.enable_background_thread = 0;
let store =
tmsl_store_open_with_config(dir_c.as_ptr(), &store_config, err.as_mut_ptr(), err_len);
assert!(!store.is_null());
let dataset_config = TmslDatasetConfigFFI {
version: TMSL_DATASET_CONFIG_FFI_VERSION,
data_segment_size: 1024 * 1024,
index_segment_size: 64 * 1024,
initial_data_segment_size: 8 * 1024,
initial_index_segment_size: 4 * 1024,
retention_window: 0,
compress_level: 6,
compress_type: crate::compress::COMPRESS_TYPE_ZSTD,
index_continuous: 0,
enable_journal: 0,
};
let name = CString::new("sensor").unwrap();
let ty = CString::new("wave").unwrap();
let dataset = tmsl_dataset_create_with_config(
store,
name.as_ptr(),
ty.as_ptr(),
&dataset_config,
err.as_mut_ptr(),
err_len,
);
assert!(!dataset.is_null());
let mut inspect = std::mem::MaybeUninit::<TmslInspectResult>::uninit();
assert_eq!(
tmsl_store_inspect_dataset(
store,
name.as_ptr(),
ty.as_ptr(),
inspect.as_mut_ptr(),
err.as_mut_ptr(),
err_len,
),
0
);
let mut inspect = unsafe { inspect.assume_init() };
assert_eq!(inspect.info.enable_journal, 0);
assert_eq!(inspect.state.has_journal, 0);
assert_eq!(inspect.state.has_min_timestamp, 0);
assert_eq!(inspect.state.has_max_timestamp, 0);
assert_eq!(inspect.state.has_base_timestamp, 0);
tmsl_free_inspect_result(&mut inspect);
let mut latest_ts: c_longlong = 123;
assert_eq!(
tmsl_dataset_latest_timestamp(dataset, &mut latest_ts, err.as_mut_ptr(), err_len),
1
);
let zero_name = CString::new("zero").unwrap();
let zero_dataset_config = TmslDatasetConfigFFI {
index_continuous: 1,
..dataset_config
};
let zero_dataset = tmsl_dataset_create_with_config(
store,
zero_name.as_ptr(),
ty.as_ptr(),
&zero_dataset_config,
err.as_mut_ptr(),
err_len,
);
assert!(!zero_dataset.is_null());
let zero_payload = [0u8];
assert_eq!(
tmsl_dataset_write(
zero_dataset,
0,
zero_payload.as_ptr(),
zero_payload.len(),
err.as_mut_ptr(),
err_len,
),
0
);
let mut inspect = std::mem::MaybeUninit::<TmslInspectResult>::uninit();
assert_eq!(
tmsl_store_inspect_dataset(
store,
zero_name.as_ptr(),
ty.as_ptr(),
inspect.as_mut_ptr(),
err.as_mut_ptr(),
err_len,
),
0
);
let mut inspect = unsafe { inspect.assume_init() };
assert_eq!(inspect.state.has_min_timestamp, 1);
assert_eq!(inspect.state.min_timestamp, 0);
assert_eq!(inspect.state.has_max_timestamp, 1);
assert_eq!(inspect.state.max_timestamp, 0);
assert_eq!(inspect.state.has_base_timestamp, 1);
assert_eq!(inspect.state.base_timestamp, 0);
tmsl_free_inspect_result(&mut inspect);
assert_eq!(
tmsl_dataset_close(zero_dataset, err.as_mut_ptr(), err_len),
0
);
let signed_name = CString::new("signed").unwrap();
let signed_dataset = tmsl_dataset_create_with_config(
store,
signed_name.as_ptr(),
ty.as_ptr(),
&dataset_config,
err.as_mut_ptr(),
err_len,
);
assert!(!signed_dataset.is_null());
assert_eq!(
tmsl_dataset_latest_timestamp(
signed_dataset,
&mut latest_ts,
err.as_mut_ptr(),
err_len
),
1
);
let minus_payload = [9u8];
assert_eq!(
tmsl_dataset_write(
signed_dataset,
-1,
minus_payload.as_ptr(),
minus_payload.len(),
err.as_mut_ptr(),
err_len,
),
0
);
let mut minus_ts: c_longlong = 0;
let mut minus_data: *mut c_uchar = std::ptr::null_mut();
let mut minus_len: usize = 0;
assert_eq!(
tmsl_dataset_read(
signed_dataset,
-1,
&mut minus_ts,
&mut minus_data,
&mut minus_len,
err.as_mut_ptr(),
err_len,
),
0
);
assert_eq!(minus_ts, -1);
assert_eq!(minus_len, minus_payload.len());
assert_eq!(
unsafe { std::slice::from_raw_parts(minus_data, minus_len) },
minus_payload
);
tmsl_data_free(minus_data as *mut c_void);
assert_eq!(
tmsl_dataset_close(signed_dataset, err.as_mut_ptr(), err_len),
0
);
let payload = [1u8, 2, 3, 4];
assert_eq!(
tmsl_dataset_write(
dataset,
100,
payload.as_ptr(),
payload.len(),
err.as_mut_ptr(),
err_len,
),
0
);
let appended = [5u8, 6];
assert_eq!(
tmsl_dataset_append(
dataset,
100,
appended.as_ptr(),
appended.len(),
err.as_mut_ptr(),
err_len,
),
0
);
let mut out_ts: c_longlong = 0;
let mut out_data: *mut c_uchar = std::ptr::null_mut();
let mut out_len: usize = 0;
assert_eq!(
tmsl_dataset_read(
dataset,
100,
&mut out_ts,
&mut out_data,
&mut out_len,
err.as_mut_ptr(),
err_len,
),
0
);
assert_eq!(out_ts, 100);
assert_eq!(out_len, payload.len() + appended.len());
assert!(!out_data.is_null());
let out_slice = unsafe { std::slice::from_raw_parts(out_data, out_len) };
assert_eq!(out_slice, &[1, 2, 3, 4, 5, 6]);
tmsl_data_free(out_data as *mut c_void);
let mut latest_data: *mut c_uchar = std::ptr::null_mut();
let mut latest_len: usize = 0;
assert_eq!(
tmsl_dataset_read_latest(
dataset,
&mut latest_ts,
&mut latest_data,
&mut latest_len,
err.as_mut_ptr(),
err_len,
),
0
);
assert_eq!(latest_ts, 100);
assert_eq!(latest_len, payload.len() + appended.len());
tmsl_data_free(latest_data as *mut c_void);
assert_eq!(tmsl_dataset_close(dataset, err.as_mut_ptr(), err_len), 0);
assert_eq!(tmsl_store_close(store, err.as_mut_ptr(), err_len), 0);
cleanup_store_dir(&dir);
}
#[test]
fn test_store_open_no_config() {
let dir = temp_store_dir("ffi_store_open_no_config");
let dir_c = CString::new(dir.to_string_lossy().as_bytes()).unwrap();
let (mut err, err_len) = err_buf();
let store = tmsl_store_open(dir_c.as_ptr(), err.as_mut_ptr(), err_len);
assert!(
!store.is_null(),
"tmsl_store_open with null config should succeed"
);
assert_eq!(tmsl_store_close(store, err.as_mut_ptr(), err_len), 0);
cleanup_store_dir(&dir);
}
#[test]
fn test_ffi_query_iterator_and_delete() {
let dir = temp_store_dir("ffi_query_iter_delete");
let dir_c = CString::new(dir.to_string_lossy().as_bytes()).unwrap();
let (mut err, err_len) = err_buf();
let mut config = TmslStoreConfigFFI::default();
assert_eq!(
tmsl_store_config_default(&mut config, err.as_mut_ptr(), err_len),
0
);
config.enable_background_thread = 0;
config.enable_journal = 0;
let store = tmsl_store_open_with_config(dir_c.as_ptr(), &config, err.as_mut_ptr(), err_len);
assert!(!store.is_null());
let name = CString::new("qid").unwrap();
let ty = CString::new("data").unwrap();
let dataset = tmsl_dataset_create(
store,
name.as_ptr(),
ty.as_ptr(),
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
err.as_mut_ptr(),
err_len,
);
assert!(!dataset.is_null());
for i in 1i64..=5 {
let data = format!("rec_{}", i);
assert_eq!(
tmsl_dataset_write(
dataset,
i,
data.as_ptr(),
data.len(),
err.as_mut_ptr(),
err_len,
),
0
);
}
assert_eq!(tmsl_dataset_flush(dataset, err.as_mut_ptr(), err_len), 0);
assert_eq!(
tmsl_dataset_delete(dataset, 3, err.as_mut_ptr(), err_len),
0
);
let iter = tmsl_dataset_query(dataset, 1, 5, err.as_mut_ptr(), err_len);
assert!(!iter.is_null());
let mut collected_ts: Vec<i64> = Vec::new();
loop {
let mut ts: c_longlong = 0;
let mut data: *mut c_uchar = std::ptr::null_mut();
let mut data_len: usize = 0;
let rc = tmsl_iter_next(
iter,
&mut ts,
&mut data,
&mut data_len,
err.as_mut_ptr(),
err_len,
);
if rc == 1 {
break; }
assert_eq!(rc, 0, "iter_next should return 0 or 1");
collected_ts.push(ts);
tmsl_iter_free_data(data);
}
assert_eq!(collected_ts, vec![1, 2, 4, 5]);
let mut length_entries: *mut TmslLengthEntry = std::ptr::null_mut();
let mut length_count: usize = 0;
assert_eq!(
tmsl_dataset_query_length(
dataset,
1,
5,
&mut length_entries,
&mut length_count,
err.as_mut_ptr(),
err_len,
),
0
);
assert_eq!(length_count, 4);
assert!(!length_entries.is_null());
let lengths = unsafe { std::slice::from_raw_parts(length_entries, length_count) };
let collected_lengths: Vec<(i64, u32)> = lengths
.iter()
.map(|entry| (entry.timestamp, entry.data_len))
.collect();
assert_eq!(collected_lengths, vec![(1, 5), (2, 5), (4, 5), (5, 5)]);
tmsl_data_free(length_entries.cast::<c_void>());
assert_eq!(
tmsl_dataset_read_exist(dataset, 3, err.as_mut_ptr(), err_len),
0,
"deleted timestamp should not be visible via FFI read_exist"
);
let mut bitmap: *mut c_uchar = std::ptr::null_mut();
let mut bitmap_len: usize = 0;
let max_bitmap_bytes = 4usize * 1024 * 1024;
let too_many_timestamps = (max_bitmap_bytes as i64) * 8 + 1;
assert_eq!(
tmsl_dataset_query_exist(
dataset,
0,
too_many_timestamps - 1,
&mut bitmap,
&mut bitmap_len,
err.as_mut_ptr(),
err_len,
),
-1,
"oversized FFI query_exist bitmap should fail"
);
tmsl_iter_close(iter);
assert_eq!(tmsl_dataset_close(dataset, err.as_mut_ptr(), err_len), 0);
assert_eq!(tmsl_store_close(store, err.as_mut_ptr(), err_len), 0);
cleanup_store_dir(&dir);
}
#[test]
fn test_ffi_queue_c_abi_push_poll_ack_lifecycle() {
let dir = temp_store_dir("ffi_queue_c_abi");
let dir_c = CString::new(dir.to_string_lossy().as_bytes()).unwrap();
let (mut err, err_len) = err_buf();
let mut config = TmslStoreConfigFFI::default();
assert_eq!(
tmsl_store_config_default(&mut config, err.as_mut_ptr(), err_len),
0
);
config.enable_background_thread = 0;
config.enable_journal = 0;
let store = tmsl_store_open_with_config(dir_c.as_ptr(), &config, err.as_mut_ptr(), err_len);
assert!(!store.is_null());
let name = CString::new("queueffi").unwrap();
let ty = CString::new("data").unwrap();
let dataset = tmsl_dataset_create(
store,
name.as_ptr(),
ty.as_ptr(),
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
err.as_mut_ptr(),
err_len,
);
assert!(!dataset.is_null());
let queue = tmsl_queue_open(dataset, err.as_mut_ptr(), err_len);
assert_ne!(queue, 0, "queue open should return a queue handle");
assert_eq!(
tmsl_store_close(store, err.as_mut_ptr(), err_len),
-1,
"store close must reject outstanding queue handles"
);
let group = CString::new("group_a").unwrap();
let consumer = tmsl_queue_consumer_open(queue, group.as_ptr(), err.as_mut_ptr(), err_len);
assert_ne!(consumer, 0, "consumer open should return a handle");
let payload = b"queued-payload";
let assigned_ts = tmsl_queue_push(
queue,
payload.as_ptr(),
payload.len(),
err.as_mut_ptr(),
err_len,
);
assert_eq!(assigned_ts, 1);
let mut out_ts: c_longlong = 0;
let mut out_data: *mut c_uchar = std::ptr::null_mut();
let mut out_len: usize = 0;
assert_eq!(
tmsl_queue_poll(
consumer,
0,
&mut out_ts,
&mut out_data,
&mut out_len,
err.as_mut_ptr(),
err_len,
),
0
);
assert_eq!(out_ts, assigned_ts);
let out_slice = unsafe { std::slice::from_raw_parts(out_data, out_len) };
assert_eq!(out_slice, payload);
tmsl_data_free(out_data as *mut c_void);
assert_eq!(
tmsl_queue_ack(consumer, out_ts, err.as_mut_ptr(), err_len),
0
);
assert_eq!(
tmsl_queue_consumer_drop(queue, consumer, err.as_mut_ptr(), err_len),
0
);
assert_eq!(tmsl_queue_close(queue, err.as_mut_ptr(), err_len), 0);
assert_eq!(tmsl_dataset_close(dataset, err.as_mut_ptr(), err_len), 0);
assert_eq!(tmsl_store_close(store, err.as_mut_ptr(), err_len), 0);
cleanup_store_dir(&dir);
}
#[test]
fn test_ffi_queue_poll_callback_register_and_clear() {
let dir = temp_store_dir("ffi_queue_poll_callback");
let dir_c = CString::new(dir.to_string_lossy().as_bytes()).unwrap();
let (mut err, err_len) = err_buf();
let mut config = TmslStoreConfigFFI::default();
assert_eq!(
tmsl_store_config_default(&mut config, err.as_mut_ptr(), err_len),
0
);
config.enable_background_thread = 0;
config.enable_journal = 0;
let store = tmsl_store_open_with_config(dir_c.as_ptr(), &config, err.as_mut_ptr(), err_len);
assert!(!store.is_null());
let name = CString::new("queuecallbackffi").unwrap();
let ty = CString::new("data").unwrap();
let dataset = tmsl_dataset_create(
store,
name.as_ptr(),
ty.as_ptr(),
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
err.as_mut_ptr(),
err_len,
);
assert!(!dataset.is_null());
let queue = tmsl_queue_open(dataset, err.as_mut_ptr(), err_len);
assert_ne!(queue, 0);
let group = CString::new("group_callback").unwrap();
let consumer = tmsl_queue_consumer_open(queue, group.as_ptr(), err.as_mut_ptr(), err_len);
assert_ne!(consumer, 0);
let hits = TestAtomicUsize::new(0);
assert_eq!(
tmsl_queue_consumer_poll_callback(
consumer,
Some(ffi_poll_callback),
&hits as *const TestAtomicUsize as *mut c_void,
err.as_mut_ptr(),
err_len,
),
0
);
let duplicate_hits = TestAtomicUsize::new(0);
assert_eq!(
tmsl_queue_consumer_poll_callback(
consumer,
Some(ffi_poll_callback),
&duplicate_hits as *const TestAtomicUsize as *mut c_void,
err.as_mut_ptr(),
err_len,
),
-1
);
let payload = b"wake";
assert_eq!(
tmsl_queue_push(
queue,
payload.as_ptr(),
payload.len(),
err.as_mut_ptr(),
err_len,
),
1
);
assert_eq!(hits.load(TestOrdering::SeqCst), 1);
assert_eq!(duplicate_hits.load(TestOrdering::SeqCst), 0);
assert_eq!(
tmsl_queue_consumer_poll_callback(
consumer,
None,
std::ptr::null_mut(),
err.as_mut_ptr(),
err_len,
),
0
);
assert_eq!(
tmsl_queue_consumer_poll_callback(
consumer,
Some(ffi_poll_callback),
&duplicate_hits as *const TestAtomicUsize as *mut c_void,
err.as_mut_ptr(),
err_len,
),
0
);
let payload = b"rearmed";
assert_eq!(
tmsl_queue_push(
queue,
payload.as_ptr(),
payload.len(),
err.as_mut_ptr(),
err_len,
),
2
);
assert_eq!(hits.load(TestOrdering::SeqCst), 1);
assert_eq!(duplicate_hits.load(TestOrdering::SeqCst), 1);
assert_eq!(tmsl_queue_close(queue, err.as_mut_ptr(), err_len), 0);
assert_eq!(tmsl_dataset_close(dataset, err.as_mut_ptr(), err_len), 0);
assert_eq!(tmsl_store_close(store, err.as_mut_ptr(), err_len), 0);
cleanup_store_dir(&dir);
}
#[test]
fn test_ffi_queue_consumer_open_with_config_validates_bounds() {
let dir = temp_store_dir("ffi_queue_consumer_config");
let dir_c = CString::new(dir.to_string_lossy().as_bytes()).unwrap();
let (mut err, err_len) = err_buf();
let mut config = TmslStoreConfigFFI::default();
assert_eq!(
tmsl_store_config_default(&mut config, err.as_mut_ptr(), err_len),
0
);
config.enable_background_thread = 0;
config.enable_journal = 0;
let store = tmsl_store_open_with_config(dir_c.as_ptr(), &config, err.as_mut_ptr(), err_len);
assert!(!store.is_null());
let name = CString::new("queuecfgffi").unwrap();
let ty = CString::new("data").unwrap();
let dataset = tmsl_dataset_create(
store,
name.as_ptr(),
ty.as_ptr(),
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
err.as_mut_ptr(),
err_len,
);
assert!(!dataset.is_null());
let queue = tmsl_queue_open(dataset, err.as_mut_ptr(), err_len);
assert_ne!(queue, 0);
let group = CString::new("configured").unwrap();
let queue_config = TmslQueueConsumerConfigFFI {
version: 1,
running_expired_seconds: 60,
max_retry_count: 7,
};
let consumer = tmsl_queue_consumer_open_with_config(
queue,
group.as_ptr(),
&queue_config,
err.as_mut_ptr(),
err_len,
);
assert_ne!(consumer, 0);
let bad_group = CString::new("bad_config").unwrap();
let invalid = TmslQueueConsumerConfigFFI {
version: 1,
running_expired_seconds: u16::MAX as u32 + 1,
max_retry_count: 1,
};
assert_eq!(
tmsl_queue_consumer_open_with_config(
queue,
bad_group.as_ptr(),
&invalid,
err.as_mut_ptr(),
err_len,
),
0
);
assert_eq!(
tmsl_queue_consumer_drop(queue, consumer, err.as_mut_ptr(), err_len),
0
);
assert_eq!(tmsl_queue_close(queue, err.as_mut_ptr(), err_len), 0);
assert_eq!(tmsl_dataset_close(dataset, err.as_mut_ptr(), err_len), 0);
assert_eq!(tmsl_store_close(store, err.as_mut_ptr(), err_len), 0);
cleanup_store_dir(&dir);
}
#[test]
fn test_ffi_journal_read_and_query_store_api() {
let dir = temp_store_dir("ffi_journal_read_query");
let dir_c = CString::new(dir.to_string_lossy().as_bytes()).unwrap();
let (mut err, err_len) = err_buf();
let mut config = TmslStoreConfigFFI::default();
assert_eq!(
tmsl_store_config_default(&mut config, err.as_mut_ptr(), err_len),
0
);
config.enable_background_thread = 0;
let store = tmsl_store_open_with_config(dir_c.as_ptr(), &config, err.as_mut_ptr(), err_len);
assert!(!store.is_null());
let name = CString::new("journalffi").unwrap();
let ty = CString::new("data").unwrap();
let dataset = tmsl_dataset_create(
store,
name.as_ptr(),
ty.as_ptr(),
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
err.as_mut_ptr(),
err_len,
);
assert!(!dataset.is_null());
let mut latest: c_longlong = 0;
assert_eq!(
tmsl_journal_latest_sequence(store, &mut latest, err.as_mut_ptr(), err_len),
0
);
assert!(latest >= 1);
let mut out_seq: c_longlong = 0;
let mut out_data: *mut c_uchar = std::ptr::null_mut();
let mut out_len: usize = 0;
assert_eq!(
tmsl_journal_read(
store,
1,
&mut out_seq,
&mut out_data,
&mut out_len,
err.as_mut_ptr(),
err_len,
),
0
);
assert_eq!(out_seq, 1);
assert!(!out_data.is_null());
let bytes = unsafe { std::slice::from_raw_parts(out_data, out_len) };
let record = crate::journal::JournalRecord::decode(bytes).unwrap();
assert_eq!(
record.kind,
crate::journal::JournalRecordKind::CreateDataset
);
tmsl_data_free(out_data as *mut c_void);
let iter = tmsl_journal_query(store, 1, latest, err.as_mut_ptr(), err_len);
assert!(!iter.is_null());
assert_eq!(
tmsl_store_close(store, err.as_mut_ptr(), err_len),
-1,
"store close must reject outstanding journal iterator"
);
assert_eq!(
tmsl_journal_iter_next(
iter,
&mut out_seq,
&mut out_data,
&mut out_len,
err.as_mut_ptr(),
err_len,
),
0
);
assert_eq!(out_seq, 1);
tmsl_data_free(out_data as *mut c_void);
tmsl_journal_iter_close(iter);
assert_eq!(tmsl_dataset_close(dataset, err.as_mut_ptr(), err_len), 0);
assert_eq!(tmsl_store_close(store, err.as_mut_ptr(), err_len), 0);
cleanup_store_dir(&dir);
}
#[test]
fn test_ffi_journal_queue_poll_ack() {
let dir = temp_store_dir("ffi_journal_queue");
let dir_c = CString::new(dir.to_string_lossy().as_bytes()).unwrap();
let (mut err, err_len) = err_buf();
let mut config = TmslStoreConfigFFI::default();
assert_eq!(
tmsl_store_config_default(&mut config, err.as_mut_ptr(), err_len),
0
);
config.enable_background_thread = 0;
let store = tmsl_store_open_with_config(dir_c.as_ptr(), &config, err.as_mut_ptr(), err_len);
assert!(!store.is_null());
let name = CString::new("journalqueueffi").unwrap();
let ty = CString::new("data").unwrap();
let dataset = tmsl_dataset_create(
store,
name.as_ptr(),
ty.as_ptr(),
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
err.as_mut_ptr(),
err_len,
);
assert!(!dataset.is_null());
let queue = tmsl_journal_queue_open(store, err.as_mut_ptr(), err_len);
assert_ne!(queue, 0);
assert_eq!(
tmsl_store_close(store, err.as_mut_ptr(), err_len),
-1,
"store close must reject outstanding journal queue"
);
let group = CString::new("journal_group").unwrap();
let queue_config = TmslQueueConsumerConfigFFI {
version: 1,
running_expired_seconds: 60,
max_retry_count: 3,
};
let consumer = tmsl_journal_queue_consumer_open_with_config(
queue,
group.as_ptr(),
&queue_config,
err.as_mut_ptr(),
err_len,
);
assert_ne!(consumer, 0);
let payload = b"journal-write";
assert_eq!(
tmsl_dataset_write(
dataset,
10,
payload.as_ptr(),
payload.len(),
err.as_mut_ptr(),
err_len,
),
0
);
let mut out_seq: c_longlong = 0;
let mut out_data: *mut c_uchar = std::ptr::null_mut();
let mut out_len: usize = 0;
assert_eq!(
tmsl_journal_queue_poll(
consumer,
100,
&mut out_seq,
&mut out_data,
&mut out_len,
err.as_mut_ptr(),
err_len,
),
0
);
assert!(out_seq > 0);
let bytes = unsafe { std::slice::from_raw_parts(out_data, out_len) };
let record = crate::journal::JournalRecord::decode(bytes).unwrap();
assert_eq!(record.kind, crate::journal::JournalRecordKind::DataWrite);
tmsl_data_free(out_data as *mut c_void);
assert_eq!(
tmsl_journal_queue_ack(consumer, out_seq, err.as_mut_ptr(), err_len),
0
);
assert_eq!(
tmsl_journal_queue_close(queue, err.as_mut_ptr(), err_len),
0
);
assert_eq!(tmsl_dataset_close(dataset, err.as_mut_ptr(), err_len), 0);
assert_eq!(tmsl_store_close(store, err.as_mut_ptr(), err_len), 0);
cleanup_store_dir(&dir);
}
#[test]
fn test_ffi_journal_queue_poll_callback_register_and_clear() {
let dir = temp_store_dir("ffi_journal_queue_poll_callback");
let dir_c = CString::new(dir.to_string_lossy().as_bytes()).unwrap();
let (mut err, err_len) = err_buf();
let mut config = TmslStoreConfigFFI::default();
assert_eq!(
tmsl_store_config_default(&mut config, err.as_mut_ptr(), err_len),
0
);
config.enable_background_thread = 0;
let store = tmsl_store_open_with_config(dir_c.as_ptr(), &config, err.as_mut_ptr(), err_len);
assert!(!store.is_null());
let name = CString::new("journalcallbackffi").unwrap();
let ty = CString::new("data").unwrap();
let dataset = tmsl_dataset_create(
store,
name.as_ptr(),
ty.as_ptr(),
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
err.as_mut_ptr(),
err_len,
);
assert!(!dataset.is_null());
let queue = tmsl_journal_queue_open(store, err.as_mut_ptr(), err_len);
assert_ne!(queue, 0);
let group = CString::new("journal_callback").unwrap();
let consumer =
tmsl_journal_queue_consumer_open(queue, group.as_ptr(), err.as_mut_ptr(), err_len);
assert_ne!(consumer, 0);
let hits = TestAtomicUsize::new(0);
assert_eq!(
tmsl_journal_queue_consumer_poll_callback(
consumer,
Some(ffi_poll_callback),
&hits as *const TestAtomicUsize as *mut c_void,
err.as_mut_ptr(),
err_len,
),
0
);
let duplicate_hits = TestAtomicUsize::new(0);
assert_eq!(
tmsl_journal_queue_consumer_poll_callback(
consumer,
Some(ffi_poll_callback),
&duplicate_hits as *const TestAtomicUsize as *mut c_void,
err.as_mut_ptr(),
err_len,
),
-1
);
let payload = b"wake";
assert_eq!(
tmsl_dataset_write(
dataset,
1,
payload.as_ptr(),
payload.len(),
err.as_mut_ptr(),
err_len,
),
0
);
assert_eq!(hits.load(TestOrdering::SeqCst), 1);
assert_eq!(duplicate_hits.load(TestOrdering::SeqCst), 0);
assert_eq!(
tmsl_journal_queue_consumer_poll_callback(
consumer,
None,
std::ptr::null_mut(),
err.as_mut_ptr(),
err_len,
),
0
);
assert_eq!(
tmsl_journal_queue_consumer_poll_callback(
consumer,
Some(ffi_poll_callback),
&duplicate_hits as *const TestAtomicUsize as *mut c_void,
err.as_mut_ptr(),
err_len,
),
0
);
assert_eq!(
tmsl_dataset_write(
dataset,
2,
payload.as_ptr(),
payload.len(),
err.as_mut_ptr(),
err_len,
),
0
);
assert_eq!(hits.load(TestOrdering::SeqCst), 1);
assert_eq!(duplicate_hits.load(TestOrdering::SeqCst), 1);
assert_eq!(
tmsl_journal_queue_close(queue, err.as_mut_ptr(), err_len),
0
);
assert_eq!(tmsl_dataset_close(dataset, err.as_mut_ptr(), err_len), 0);
assert_eq!(tmsl_store_close(store, err.as_mut_ptr(), err_len), 0);
cleanup_store_dir(&dir);
}
#[test]
fn test_ffi_query_iterator_uses_index_entry_snapshot() {
let dir = temp_store_dir("ffi_query_iter_snapshot");
let dir_c = CString::new(dir.to_string_lossy().as_bytes()).unwrap();
let (mut err, err_len) = err_buf();
let mut config = TmslStoreConfigFFI::default();
assert_eq!(
tmsl_store_config_default(&mut config, err.as_mut_ptr(), err_len),
0
);
config.enable_background_thread = 0;
config.enable_journal = 0;
let store = tmsl_store_open_with_config(dir_c.as_ptr(), &config, err.as_mut_ptr(), err_len);
assert!(!store.is_null());
let name = CString::new("snapffi").unwrap();
let ty = CString::new("data").unwrap();
let dataset = tmsl_dataset_create(
store,
name.as_ptr(),
ty.as_ptr(),
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
err.as_mut_ptr(),
err_len,
);
assert!(!dataset.is_null());
for ts in 1i64..=1100 {
let data = format!("rec_{ts}");
assert_eq!(
tmsl_dataset_write(
dataset,
ts,
data.as_ptr(),
data.len(),
err.as_mut_ptr(),
err_len,
),
0
);
}
let iter = tmsl_dataset_query(dataset, 500, 501, err.as_mut_ptr(), err_len);
assert!(!iter.is_null());
assert_eq!(
tmsl_dataset_delete(dataset, 500, err.as_mut_ptr(), err_len),
0
);
let mut ts: c_longlong = 0;
let mut data: *mut c_uchar = std::ptr::null_mut();
let mut data_len: usize = 0;
assert_eq!(
tmsl_iter_next(
iter,
&mut ts,
&mut data,
&mut data_len,
err.as_mut_ptr(),
err_len,
),
0
);
assert_eq!(ts, 500);
let out_slice = unsafe { std::slice::from_raw_parts(data, data_len) };
assert_eq!(out_slice, b"rec_500");
tmsl_iter_free_data(data);
tmsl_iter_close(iter);
assert_eq!(tmsl_dataset_close(dataset, err.as_mut_ptr(), err_len), 0);
assert_eq!(tmsl_store_close(store, err.as_mut_ptr(), err_len), 0);
cleanup_store_dir(&dir);
}
#[test]
fn test_ffi_tick_and_next_delay() {
let dir = temp_store_dir("ffi_tick_delay");
let dir_c = CString::new(dir.to_string_lossy().as_bytes()).unwrap();
let (mut err, err_len) = err_buf();
let mut config = TmslStoreConfigFFI::default();
assert_eq!(
tmsl_store_config_default(&mut config, err.as_mut_ptr(), err_len),
0
);
config.enable_background_thread = 0;
config.enable_journal = 0;
let store = tmsl_store_open_with_config(dir_c.as_ptr(), &config, err.as_mut_ptr(), err_len);
assert!(!store.is_null());
let mut executed: u32 = 99;
let mut delay_ms: u64 = 99;
assert_eq!(
tmsl_store_tick_background_tasks(
store,
&mut executed,
&mut delay_ms,
err.as_mut_ptr(),
err_len,
),
0
);
assert!(executed <= 4, "executed tasks bounded by 4");
assert_eq!(
tmsl_store_next_background_delay(store, &mut delay_ms, err.as_mut_ptr(), err_len),
0
);
assert!(
delay_ms <= 15_000,
"delay bounded by default flush_interval (15s)"
);
assert_eq!(tmsl_store_close(store, err.as_mut_ptr(), err_len), 0);
cleanup_store_dir(&dir);
}
#[test]
fn test_ffi_error_path_err_buf_output() {
let dir = temp_store_dir("ffi_error_path");
let dir_c = CString::new(dir.to_string_lossy().as_bytes()).unwrap();
let (mut err, err_len) = err_buf();
let mut config = TmslStoreConfigFFI::default();
assert_eq!(
tmsl_store_config_default(&mut config, err.as_mut_ptr(), err_len),
0
);
config.enable_background_thread = 0;
config.enable_journal = 0;
let store = tmsl_store_open_with_config(dir_c.as_ptr(), &config, err.as_mut_ptr(), err_len);
assert!(!store.is_null());
let bad_name = CString::new("nonexistent").unwrap();
let bad_ty = CString::new("data").unwrap();
let (mut err2, err_len2) = err_buf();
let null_ds = tmsl_dataset_open(
store,
bad_name.as_ptr(),
bad_ty.as_ptr(),
err2.as_mut_ptr(),
err_len2,
);
assert!(
null_ds.is_null(),
"opening non-existent dataset should return null"
);
let err_str = unsafe { std::ffi::CStr::from_ptr(err2.as_ptr()) }
.to_str()
.unwrap_or("");
assert!(
!err_str.is_empty(),
"err_buf should contain an error message"
);
let name = CString::new("errds").unwrap();
let ty = CString::new("data").unwrap();
let dataset = tmsl_dataset_create(
store,
name.as_ptr(),
ty.as_ptr(),
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
err.as_mut_ptr(),
err_len,
);
assert!(!dataset.is_null());
let (mut err3, err_len3) = err_buf();
assert_eq!(
tmsl_store_close(store, err3.as_mut_ptr(), err_len3),
-1,
"store close must reject outstanding dataset handles"
);
let close_err = unsafe { std::ffi::CStr::from_ptr(err3.as_ptr()) }
.to_str()
.unwrap_or("");
assert!(
close_err.contains("outstanding"),
"err_buf should mention outstanding handles, got: {}",
close_err
);
assert_eq!(tmsl_dataset_close(dataset, err.as_mut_ptr(), err_len), 0);
assert_eq!(tmsl_store_close(store, err.as_mut_ptr(), err_len), 0);
cleanup_store_dir(&dir);
}
}