pub struct Aeron { /* private fields */ }Implementations§
Source§impl Aeron
impl Aeron
Sourcepub fn async_add_counter(
&self,
type_id: i32,
key_buffer: &[u8],
label_buffer: &str,
) -> Result<AeronAsyncAddCounter, AeronCError>
pub fn async_add_counter( &self, type_id: i32, key_buffer: &[u8], label_buffer: &str, ) -> Result<AeronAsyncAddCounter, AeronCError>
§Handler lifetime and async close
If this call takes a Handler, the conductor may invoke its callbacks
after the resource’s close() or drop returns. The C close is asynchronous.
The new resource keeps a clone of its Aeron client. The client keeps
registered handlers alive until its last owning reference drops and C cleanup
finishes. Closing the resource earlier does not free its handlers.
You do not need to call release().
Each registration adds a handler clone to the client. The closures and any values they capture stay in memory until client cleanup, even after the conductor finishes closing the resource.
Source§impl Aeron
impl Aeron
Sourcepub fn add_counter(
&self,
type_id: i32,
key_buffer: &[u8],
label_buffer: &str,
timeout: Duration,
) -> Result<AeronCounter, AeronCError>
pub fn add_counter( &self, type_id: i32, key_buffer: &[u8], label_buffer: &str, timeout: Duration, ) -> Result<AeronCounter, AeronCError>
Blocking convenience wrapper around the async add operation.
For examples and tests. Blocks the calling thread in a busy-poll loop until
the resource is available or timeout elapses. In production, call the
async_add_* variant and drive its poll() from your event loop.
§Event loop example
// Don't block. Drive the async poller from your loop
let poller = client.async_add_*(...)?;
loop {
if let Some(resource) = poller.poll()? {
break; // ready
}
do_other_work(); // service other subscriptions, timers, etc.
}poll_blocking on the async poller also blocks the calling thread.
Source§impl Aeron
impl Aeron
Sourcepub fn async_add_exclusive_publication(
&self,
uri: &CStr,
stream_id: i32,
) -> Result<AeronAsyncAddExclusivePublication, AeronCError>
pub fn async_add_exclusive_publication( &self, uri: &CStr, stream_id: i32, ) -> Result<AeronAsyncAddExclusivePublication, AeronCError>
§Handler lifetime and async close
If this call takes a Handler, the conductor may invoke its callbacks
after the resource’s close() or drop returns. The C close is asynchronous.
The new resource keeps a clone of its Aeron client. The client keeps
registered handlers alive until its last owning reference drops and C cleanup
finishes. Closing the resource earlier does not free its handlers.
You do not need to call release().
Each registration adds a handler clone to the client. The closures and any values they capture stay in memory until client cleanup, even after the conductor finishes closing the resource.
Source§impl Aeron
impl Aeron
Sourcepub fn add_exclusive_publication(
&self,
uri: &CStr,
stream_id: i32,
timeout: Duration,
) -> Result<AeronExclusivePublication, AeronCError>
pub fn add_exclusive_publication( &self, uri: &CStr, stream_id: i32, timeout: Duration, ) -> Result<AeronExclusivePublication, AeronCError>
Blocking convenience wrapper around the async add operation.
For examples and tests. Blocks the calling thread in a busy-poll loop until
the resource is available or timeout elapses. In production, call the
async_add_* variant and drive its poll() from your event loop.
§Event loop example
// Don't block. Drive the async poller from your loop
let poller = client.async_add_*(...)?;
loop {
if let Some(resource) = poller.poll()? {
break; // ready
}
do_other_work(); // service other subscriptions, timers, etc.
}poll_blocking on the async poller also blocks the calling thread.
Source§impl Aeron
impl Aeron
Sourcepub fn async_add_publication(
&self,
uri: &CStr,
stream_id: i32,
) -> Result<AeronAsyncAddPublication, AeronCError>
pub fn async_add_publication( &self, uri: &CStr, stream_id: i32, ) -> Result<AeronAsyncAddPublication, AeronCError>
§Handler lifetime and async close
If this call takes a Handler, the conductor may invoke its callbacks
after the resource’s close() or drop returns. The C close is asynchronous.
The new resource keeps a clone of its Aeron client. The client keeps
registered handlers alive until its last owning reference drops and C cleanup
finishes. Closing the resource earlier does not free its handlers.
You do not need to call release().
Each registration adds a handler clone to the client. The closures and any values they capture stay in memory until client cleanup, even after the conductor finishes closing the resource.
Source§impl Aeron
impl Aeron
Sourcepub fn add_publication(
&self,
uri: &CStr,
stream_id: i32,
timeout: Duration,
) -> Result<AeronPublication, AeronCError>
pub fn add_publication( &self, uri: &CStr, stream_id: i32, timeout: Duration, ) -> Result<AeronPublication, AeronCError>
Blocking convenience wrapper around the async add operation.
For examples and tests. Blocks the calling thread in a busy-poll loop until
the resource is available or timeout elapses. In production, call the
async_add_* variant and drive its poll() from your event loop.
§Event loop example
// Don't block. Drive the async poller from your loop
let poller = client.async_add_*(...)?;
loop {
if let Some(resource) = poller.poll()? {
break; // ready
}
do_other_work(); // service other subscriptions, timers, etc.
}poll_blocking on the async poller also blocks the calling thread.
Source§impl Aeron
impl Aeron
Sourcepub fn async_add_subscription<AeronAvailableImageHandlerImpl: AeronAvailableImageCallback + 'static, AeronUnavailableImageHandlerImpl: AeronUnavailableImageCallback + 'static>(
&self,
uri: &CStr,
stream_id: i32,
on_available_image_handler: Option<&Handler<AeronAvailableImageHandlerImpl>>,
on_unavailable_image_handler: Option<&Handler<AeronUnavailableImageHandlerImpl>>,
) -> Result<AeronAsyncAddSubscription, AeronCError>
pub fn async_add_subscription<AeronAvailableImageHandlerImpl: AeronAvailableImageCallback + 'static, AeronUnavailableImageHandlerImpl: AeronUnavailableImageCallback + 'static>( &self, uri: &CStr, stream_id: i32, on_available_image_handler: Option<&Handler<AeronAvailableImageHandlerImpl>>, on_unavailable_image_handler: Option<&Handler<AeronUnavailableImageHandlerImpl>>, ) -> Result<AeronAsyncAddSubscription, AeronCError>
§Handler lifetime and async close
If this call takes a Handler, the conductor may invoke its callbacks
after the resource’s close() or drop returns. The C close is asynchronous.
The new resource keeps a clone of its Aeron client. The client keeps
registered handlers alive until its last owning reference drops and C cleanup
finishes. Closing the resource earlier does not free its handlers.
You do not need to call release().
Each registration adds a handler clone to the client. The closures and any values they capture stay in memory until client cleanup, even after the conductor finishes closing the resource.
Source§impl Aeron
impl Aeron
Sourcepub fn add_subscription<AeronAvailableImageHandlerImpl: AeronAvailableImageCallback + 'static, AeronUnavailableImageHandlerImpl: AeronUnavailableImageCallback + 'static>(
&self,
uri: &CStr,
stream_id: i32,
on_available_image_handler: Option<&Handler<AeronAvailableImageHandlerImpl>>,
on_unavailable_image_handler: Option<&Handler<AeronUnavailableImageHandlerImpl>>,
timeout: Duration,
) -> Result<AeronSubscription, AeronCError>
pub fn add_subscription<AeronAvailableImageHandlerImpl: AeronAvailableImageCallback + 'static, AeronUnavailableImageHandlerImpl: AeronUnavailableImageCallback + 'static>( &self, uri: &CStr, stream_id: i32, on_available_image_handler: Option<&Handler<AeronAvailableImageHandlerImpl>>, on_unavailable_image_handler: Option<&Handler<AeronUnavailableImageHandlerImpl>>, timeout: Duration, ) -> Result<AeronSubscription, AeronCError>
Blocking convenience wrapper around the async add operation.
For examples and tests. Blocks the calling thread in a busy-poll loop until
the resource is available or timeout elapses. In production, call the
async_add_* variant and drive its poll() from your event loop.
§Event loop example
// Don't block. Drive the async poller from your loop
let poller = client.async_add_*(...)?;
loop {
if let Some(resource) = poller.poll()? {
break; // ready
}
do_other_work(); // service other subscriptions, timers, etc.
}poll_blocking on the async poller also blocks the calling thread.
Source§impl Aeron
impl Aeron
Sourcepub fn new(context: &AeronContext) -> Result<Self, AeronCError>
pub fn new(context: &AeronContext) -> Result<Self, AeronCError>
Sourcepub fn fprintf(
src_: &CStr,
line_: u64,
stream: *mut c_void,
format: &CStr,
) -> Result<i32, AeronCError>
pub fn fprintf( src_: &CStr, line_: u64, stream: *mut c_void, format: &CStr, ) -> Result<i32, AeronCError>
Global file writing method, allows for interposition
Sourcepub fn set_fprintf_handler(
fn_: aeron_fprintf_handler_t,
) -> aeron_fprintf_handler_t
pub fn set_fprintf_handler( fn_: aeron_fprintf_handler_t, ) -> aeron_fprintf_handler_t
update the fprintf_handler, return previously installed handler
Sourcepub fn get_fprintf_handler() -> aeron_fprintf_handler_t
pub fn get_fprintf_handler() -> aeron_fprintf_handler_t
return the fprintf_handler
Sourcepub fn start(&self) -> Result<i32, AeronCError>
pub fn start(&self) -> Result<i32, AeronCError>
Start an Aeron. This may spawn a thread for the Client Conductor.
§Return
0 for success and -1 for error.
Sourcepub fn main_do_work(&self) -> Result<i32, AeronCError>
pub fn main_do_work(&self) -> Result<i32, AeronCError>
Call the Conductor main do_work duty cycle once.
Client must have been created with use conductor invoker set to true.
§Return
0 for success and -1 for error.
Sourcepub fn main_idle_strategy(&self, work_count: c_int)
pub fn main_idle_strategy(&self, work_count: c_int)
Sourcepub fn is_closed(&self) -> bool
pub fn is_closed(&self) -> bool
Determines if the client has been closed, e.g. via a driver timeout. Don’t call this method after calling aeron_close as that will have already freed the associated memory.
§Return
true if it has been closed, false otherwise.
Sourcepub fn print_counters(
&self,
stream_out: Option<unsafe extern "C" fn(arg1: *const c_char)>,
)
pub fn print_counters( &self, stream_out: Option<unsafe extern "C" fn(arg1: *const c_char)>, )
Call stream_out to print the counter labels and values.
§Parameters
stream_outto call for each label and value.
Sourcepub fn context(&self) -> Ref<'_, AeronContext>
pub fn context(&self) -> Ref<'_, AeronContext>
Return the AeronContext that is in use by the given client.
§Return
the AeronContext for the given client or NULL for an error.
Sourcepub fn next_correlation_id(&self) -> i64
pub fn next_correlation_id(&self) -> i64
Sourcepub fn async_add_publication_cancel(
&self,
async_: &AeronAsyncAddPublication,
) -> Result<i32, AeronCError>
pub fn async_add_publication_cancel( &self, async_: &AeronAsyncAddPublication, ) -> Result<i32, AeronCError>
Cancel an in-progress aeron_async_add_publication operation.
Will eventually free the given instance. If a publication gets created by
the time cancellation happens, it will get removed.AeronAsyncAddPublication
Note: The above guarantees only apply when a call to this method succeeds, i.e. return value is zero. If a
return value is non-zero the operation won’t be canceled and the instance
won’t be freed.AeronAsyncAddPublication
§Return
0 for success or -1 for error.
Sourcepub fn async_remove_publication<AeronNotificationHandlerImpl: AeronNotificationCallback + 'static>(
&self,
registration_id: i64,
on_complete: Option<AeronNotificationHandlerImpl>,
) -> Result<Option<Handler<AeronNotificationHandlerImpl>>, AeronCError>
pub fn async_remove_publication<AeronNotificationHandlerImpl: AeronNotificationCallback + 'static>( &self, registration_id: i64, on_complete: Option<AeronNotificationHandlerImpl>, ) -> Result<Option<Handler<AeronNotificationHandlerImpl>>, AeronCError>
Asynchronously remove a publication.
If there is an AeronPublication object for that publication, it will get closed and freed.
§Parameters
registration_idof the publication to be removed.on_completeoptional callback to execute once the publication has been removed. This may happen on a separate thread, so the caller should ensure that clientd has the appropriate lifetime. Use NULL if not needed.on_complete_clientdparameter to pass to the on_complete callback.
§Return
0 for success or -1 for error.
An owned wrapper keeps the callback alive until C cleanup finishes.
If the wrapper is borrowed, keep the returned Handler alive while C can call it.
Dropping the handler does not unregister the callback.
Returns the Handler so you can access its state. You can pass a closure with a matching signature.
Sourcepub fn async_add_exclusive_publication_cancel(
&self,
async_: &AeronAsyncAddExclusivePublication,
) -> Result<i32, AeronCError>
pub fn async_add_exclusive_publication_cancel( &self, async_: &AeronAsyncAddExclusivePublication, ) -> Result<i32, AeronCError>
Cancel an in-progress aeron_async_add_exclusive_publication operation.
Will eventually free the given instance. If a publication gets
created by the time cancellation happens, it will get removed.AeronAsyncAddExclusivePublication
Note: The above guarantees only apply when a call to this method succeeds, i.e. return value is zero. If a
return value is non-zero the operation won’t be canceled and the
instance won’t be freed.AeronAsyncAddExclusivePublication
§Return
0 for success or -1 for error.
Sourcepub fn async_remove_exclusive_publication<AeronNotificationHandlerImpl: AeronNotificationCallback + 'static>(
&self,
registration_id: i64,
on_complete: Option<AeronNotificationHandlerImpl>,
) -> Result<Option<Handler<AeronNotificationHandlerImpl>>, AeronCError>
pub fn async_remove_exclusive_publication<AeronNotificationHandlerImpl: AeronNotificationCallback + 'static>( &self, registration_id: i64, on_complete: Option<AeronNotificationHandlerImpl>, ) -> Result<Option<Handler<AeronNotificationHandlerImpl>>, AeronCError>
Asynchronously remove an exclusive publication.
If there is an AeronExclusivePublication object for that publication, it will get closed and freed.
§Parameters
registration_idof the exclusive publication to be removed.on_completeoptional callback to execute once the exclusive publication has been removed. This may happen on a separate thread, so the caller should ensure that clientd has the appropriate lifetime. Use NULL if not needed.on_complete_clientdparameter to pass to the on_complete callback.
§Return
0 for success or -1 for error.
An owned wrapper keeps the callback alive until C cleanup finishes.
If the wrapper is borrowed, keep the returned Handler alive while C can call it.
Dropping the handler does not unregister the callback.
Returns the Handler so you can access its state. You can pass a closure with a matching signature.
Sourcepub fn async_add_subscription_cancel(
&self,
async_: &AeronAsyncAddSubscription,
) -> Result<i32, AeronCError>
pub fn async_add_subscription_cancel( &self, async_: &AeronAsyncAddSubscription, ) -> Result<i32, AeronCError>
Cancel an in-progress aeron_async_add_subscription operation.
Will eventually free the given instance. If a subscription gets created
by the time cancellation happens, it will get removed.AeronAsyncAddSubscription
Note: The above guarantees only apply when a call to this method succeeds, i.e. return value is zero. If a
return value is non-zero the operation won’t be canceled and the instance
won’t be freed.AeronAsyncAddSubscription
§Return
0 for success or -1 for error.
Sourcepub fn async_remove_subscription<AeronNotificationHandlerImpl: AeronNotificationCallback + 'static>(
&self,
registration_id: i64,
on_complete: Option<AeronNotificationHandlerImpl>,
) -> Result<Option<Handler<AeronNotificationHandlerImpl>>, AeronCError>
pub fn async_remove_subscription<AeronNotificationHandlerImpl: AeronNotificationCallback + 'static>( &self, registration_id: i64, on_complete: Option<AeronNotificationHandlerImpl>, ) -> Result<Option<Handler<AeronNotificationHandlerImpl>>, AeronCError>
Asynchronously remove a subscription.
If there is an AeronSubscription object for that subscription, it will get closed and freed.
§Parameters
registration_idof the subscription to be removed.on_completeoptional callback to execute once the subscription has been removed. This may happen on a separate thread, so the caller should ensure that clientd has the appropriate lifetime. Use NULL if not needed.on_complete_clientdparameter to pass to the on_complete callback.
§Return
0 for success or -1 for error.
An owned wrapper keeps the callback alive until C cleanup finishes.
If the wrapper is borrowed, keep the returned Handler alive while C can call it.
Dropping the handler does not unregister the callback.
Returns the Handler so you can access its state. You can pass a closure with a matching signature.
Sourcepub fn counters_reader(&self) -> Ref<'_, AeronCountersReader>
pub fn counters_reader(&self) -> Ref<'_, AeronCountersReader>
Return a reference to the counters reader of the given client.
The AeronCountersReader is maintained by the client. And should not be freed.
§Return
AeronCountersReader or NULL for error.
Sourcepub fn async_add_counter_cancel(
&self,
async_: &AeronAsyncAddCounter,
) -> Result<i32, AeronCError>
pub fn async_add_counter_cancel( &self, async_: &AeronAsyncAddCounter, ) -> Result<i32, AeronCError>
Cancel an in-progress aeron_async_add_counter operation. Not applicable to
aeron_async_add_static_counter, i.e. attempt to cancel static counter will fail with an error.
Will eventually free the given instance. If a counter gets created by the time
cancellation happens, it will get removed.AeronAsyncAddCounter
Note: The above guarantees only apply when a call to this method succeeds, i.e. return value is zero. If a
return value is non-zero the operation won’t be canceled and the instance
won’t be freed.AeronAsyncAddCounter
§Return
0 for success or -1 for error.
Sourcepub fn async_remove_counter<AeronNotificationHandlerImpl: AeronNotificationCallback + 'static>(
&self,
registration_id: i64,
on_complete: Option<AeronNotificationHandlerImpl>,
) -> Result<Option<Handler<AeronNotificationHandlerImpl>>, AeronCError>
pub fn async_remove_counter<AeronNotificationHandlerImpl: AeronNotificationCallback + 'static>( &self, registration_id: i64, on_complete: Option<AeronNotificationHandlerImpl>, ) -> Result<Option<Handler<AeronNotificationHandlerImpl>>, AeronCError>
Asynchronously remove a counter. Not applicable to static counters.
If there is an AeronCounter object for that counter, it will get closed and freed.
§Parameters
registration_idof the counter to be removed.on_completeoptional callback to execute once the counter has been removed. This may happen on a separate thread, so the caller should ensure that clientd has the appropriate lifetime. Use NULL if not needed.on_complete_clientdparameter to pass to the on_complete callback.
§Return
0 for success or -1 for error.
An owned wrapper keeps the callback alive until C cleanup finishes.
If the wrapper is borrowed, keep the returned Handler alive while C can call it.
Dropping the handler does not unregister the callback.
Returns the Handler so you can access its state. You can pass a closure with a matching signature.
Sourcepub fn add_available_counter_handler(
&self,
pair: &AeronAvailableCounterPair,
) -> Result<i32, AeronCError>
pub fn add_available_counter_handler( &self, pair: &AeronAvailableCounterPair, ) -> Result<i32, AeronCError>
Sourcepub fn remove_available_counter_handler(
&self,
pair: &AeronAvailableCounterPair,
) -> Result<i32, AeronCError>
pub fn remove_available_counter_handler( &self, pair: &AeronAvailableCounterPair, ) -> Result<i32, AeronCError>
Remove a previously added handler to be called when a new counter becomes unavailable or goes away.
NOTE: This function blocks until the handler is removed by the client conductor thread.
§Parameters
pairholding the handler to call and a clientd to pass when called.
§Return
0 for success and -1 for error
Sourcepub fn add_close_handler(
&self,
pair: &AeronCloseClientPair,
) -> Result<i32, AeronCError>
pub fn add_close_handler( &self, pair: &AeronCloseClientPair, ) -> Result<i32, AeronCError>
Sourcepub fn remove_close_handler(
&self,
pair: &AeronCloseClientPair,
) -> Result<i32, AeronCError>
pub fn remove_close_handler( &self, pair: &AeronCloseClientPair, ) -> Result<i32, AeronCError>
Sourcepub fn version_full() -> &'static str
pub fn version_full() -> &'static str
Return full version and build string.
§Return
full version and build string. SAFETY: this is static for performance reasons, so you should not store this without copying it!!
Sourcepub fn version_text() -> &'static str
pub fn version_text() -> &'static str
Return version text.
§Return
version text. SAFETY: this is static for performance reasons, so you should not store this without copying it!!
Sourcepub fn version_major() -> Result<i32, AeronCError>
pub fn version_major() -> Result<i32, AeronCError>
Sourcepub fn version_minor() -> Result<i32, AeronCError>
pub fn version_minor() -> Result<i32, AeronCError>
Sourcepub fn version_patch() -> Result<i32, AeronCError>
pub fn version_patch() -> Result<i32, AeronCError>
Sourcepub fn version_gitsha() -> &'static str
pub fn version_gitsha() -> &'static str
Return the git sha for the current build.
§Return
git version SAFETY: this is static for performance reasons, so you should not store this without copying it!!
Sourcepub fn nano_clock() -> i64
pub fn nano_clock() -> i64
Return time in nanoseconds for machine. Is not wall clock time.
§Return
nanoseconds since epoch for machine.
Sourcepub fn epoch_clock() -> i64
pub fn epoch_clock() -> i64
Sourcepub fn is_driver_active(
dirname: &CStr,
timeout_ms: i64,
log_func: aeron_log_func_t,
) -> bool
pub fn is_driver_active( dirname: &CStr, timeout_ms: i64, log_func: aeron_log_func_t, ) -> bool
Sourcepub fn properties_buffer_load(buffer: &CStr) -> Result<i32, AeronCError>
pub fn properties_buffer_load(buffer: &CStr) -> Result<i32, AeronCError>
Sourcepub fn properties_file_load(filename: &CStr) -> Result<i32, AeronCError>
pub fn properties_file_load(filename: &CStr) -> Result<i32, AeronCError>
Sourcepub fn properties_http_load(url: &CStr) -> Result<i32, AeronCError>
pub fn properties_http_load(url: &CStr) -> Result<i32, AeronCError>
Sourcepub fn properties_load(url_or_filename: &CStr) -> Result<i32, AeronCError>
pub fn properties_load(url_or_filename: &CStr) -> Result<i32, AeronCError>
Load properties based on URL or filename. If string contains file or http URL, it will attempt to load properties from a file or http as indicated. If not a URL, then it will try to load the string as a filename.
§Parameters
url_or_filenameto load properties from.
§Return
0 for success and -1 for error.
Sourcepub fn errcode() -> Result<i32, AeronCError>
pub fn errcode() -> Result<i32, AeronCError>
Return current aeron error code (errno) for calling thread.
§Return
aeron error code for calling thread.
Sourcepub fn errmsg() -> &'static str
pub fn errmsg() -> &'static str
Return the current aeron error message for calling thread.
§Return
aeron error message for calling thread. SAFETY: this is static for performance reasons, so you should not store this without copying it!!
Sourcepub fn default_path(path: &mut [u8]) -> Result<i32, AeronCError>
pub fn default_path(path: &mut [u8]) -> Result<i32, AeronCError>
Get the default path used by the Aeron media driver.
§Parameters
pathbuffer to store the path.path_lengthspace available in the buffer
§Return
-1 if there is an issue or the number of bytes written to path excluding the terminator \0. If this
is equal to or greater than the path_length then the path has been truncated.
pub fn semantic_version_compose(major: u8, minor: u8, patch: u8) -> i32
pub fn semantic_version_major(version: i32) -> u8
pub fn semantic_version_minor(version: i32) -> u8
pub fn semantic_version_patch(version: i32) -> u8
pub fn thread_set_name(name: &CStr) -> Result<i32, AeronCError>
pub fn thread_get_name(name_buf: &mut [u8]) -> Result<i32, AeronCError>
pub fn nano_sleep(nanoseconds: u64)
pub fn micro_sleep(microseconds: c_uint)
pub fn thread_set_affinity( name: &CStr, cpu_affinity_no: u8, ) -> Result<i32, AeronCError>
pub fn thread_get_affinity(cpu_affinity: *mut u8) -> Result<i32, AeronCError>
pub fn mutex_init(mutex: *mut aeron_mutex_t) -> Result<i32, AeronCError>
pub fn mutex_destroy(mutex: *mut aeron_mutex_t) -> Result<i32, AeronCError>
pub fn mutex_lock(mutex: *mut aeron_mutex_t) -> Result<i32, AeronCError>
pub fn mutex_unlock(mutex: *mut aeron_mutex_t) -> Result<i32, AeronCError>
pub fn set_errno(errcode: c_int)
Sourcepub fn error_code_str(errcode: c_int) -> &'static str
pub fn error_code_str(errcode: c_int) -> &'static str
SAFETY: this is static for performance reasons, so you should not store this without copying it!!
pub fn err_set( errcode: c_int, function: &CStr, filename: &CStr, line_number: c_int, format: &CStr, )
pub fn err_append( function: &CStr, filename: &CStr, line_number: c_int, format: &CStr, )
pub fn err_clear()
pub fn randomised_int32() -> i32
pub fn format_date(str_: &mut [u8], timestamp: i64)
pub fn format_number_to_locale( value: c_longlong, buffer: &mut [u8], ) -> *mut c_char
pub fn format_to_hex(str_: &mut [u8], data: &[u8])
pub fn digit_count(value: u32) -> Result<i32, AeronCError>
pub fn free(ptr: *mut c_void)
pub fn res_header_entry_length( res: *mut c_void, remaining: usize, ) -> Result<i32, AeronCError>
pub fn logbuffer_check_term_length(term_length: u64) -> Result<i32, AeronCError>
pub fn logbuffer_check_page_size(page_size: u64) -> Result<i32, AeronCError>
pub fn is_directory(path: &CStr) -> Result<i32, AeronCError>
pub fn delete_directory(directory: &CStr) -> Result<i32, AeronCError>
pub fn mkdir_recursive( pathname: &CStr, permission: c_int, ) -> Result<i32, AeronCError>
pub fn msync(addr: *mut c_void, length: usize) -> Result<i32, AeronCError>
pub fn delete_file(path: &CStr) -> Result<i32, AeronCError>
Sourcepub fn realpath(path: &CStr, resolved_path: &mut [u8]) -> &'static str
pub fn realpath(path: &CStr, resolved_path: &mut [u8]) -> &'static str
SAFETY: this is static for performance reasons, so you should not store this without copying it!!
Sourcepub fn tmpdir(path: &mut [u8]) -> &'static str
pub fn tmpdir(path: &mut [u8]) -> &'static str
SAFETY: this is static for performance reasons, so you should not store this without copying it!!
pub fn file_exists(path: &CStr) -> bool
pub fn ftell(stream: *mut c_void) -> i64
Sourcepub fn open_file_append(path: &CStr) -> *mut c_void
pub fn open_file_append(path: &CStr) -> *mut c_void
pub fn file_length(path: &CStr) -> i64
pub fn usable_fs_space(path: &CStr) -> u64
pub fn usable_fs_space_disabled(path: &CStr) -> u64
pub fn ipc_publication_location( dst: &mut [u8], aeron_dir: &CStr, correlation_id: i64, ) -> Result<i32, AeronCError>
pub fn network_publication_location( dst: &mut [u8], aeron_dir: &CStr, correlation_id: i64, ) -> Result<i32, AeronCError>
pub fn temp_filename(filename: &mut [u8]) -> usize
pub fn file_resolve( parent: &CStr, child: &CStr, buffer: &mut [u8], ) -> Result<i32, AeronCError>
pub fn agent_on_start_load(name: &CStr) -> aeron_agent_on_start_func_t
pub fn get_inner(&self) -> *mut aeron_t
Sourcepub unsafe fn get_inner_mut(&self) -> &mut aeron_t
pub unsafe fn get_inner_mut(&self) -> &mut aeron_t
Mutable access to the underlying C struct, minted from &self: nothing
prevents two live &mut at once, so the caller must ensure exclusive
access for the lifetime of the returned reference.
§Safety
No other reference (& or &mut) to the underlying struct may be
alive while the returned &mut is in use.
pub fn get_inner_ref(&self) -> &aeron_t
Source§impl Aeron
impl Aeron
Sourcepub fn close(self) -> Result<(), AeronCError>
pub fn close(self) -> Result<(), AeronCError>
Releases this handle and closes the C client once the last reference drops.
The C client owns and frees every child resource (publications,
subscriptions, counters) when it closes, so while children or clones
are alive this is deferred, equivalent to drop, and the surviving
handles remain usable. The C close runs when the final
reference (child or clone) is released.
Sourcepub unsafe fn close_now(self) -> Result<(), AeronCError>
pub unsafe fn close_now(self) -> Result<(), AeronCError>
Closes the C client immediately, even if children or clones are alive.
Clones of this handle are safe afterwards (their shared pointer is nulled). Child handles are not:
§Safety
The C client frees every child resource (publications, subscriptions,
counters) during this call, so surviving child handles dangle. Any use
is use-after-free, including their Drop, which calls the C close
on the freed pointer (double free). You must std::mem::forget every
surviving child, or never return (e.g. std::process::exit). Prefer
Self::close, which defers until the last reference drops.
Source§impl Aeron
impl Aeron
Sourcepub fn connect(dir: Option<&str>) -> Result<Aeron, AeronCError>
pub fn connect(dir: Option<&str>) -> Result<Aeron, AeronCError>
Connect to a media driver in one call: context, client, and conductor start.
dir is the media driver directory (None uses the aeron default). For tuned
setups with custom error handlers, driver timeout or idle strategy, build the
AeronContext yourself and use Aeron::new.
Sourcepub fn connect_default() -> Result<Aeron, AeronCError>
pub fn connect_default() -> Result<Aeron, AeronCError>
Connect to a media driver in the default aeron directory. Equivalent to
Self::connect(None), but reads more naturally at the call site.
Sourcepub fn connect_dir(dir: &str) -> Result<Aeron, AeronCError>
pub fn connect_dir(dir: &str) -> Result<Aeron, AeronCError>
Connect to a media driver in dir. Equivalent to
Self::connect(Some(dir)).