Struct Aeron 

pub struct Aeron { /* private fields */ }

Implementations

impl Aeron

pub fn async_add_counter( &self, type_id: i32, key_buffer: &[u8], label_buffer: &str, ) -> Result<AeronAsyncAddCounter, AeronCError>

impl Aeron

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.

Convenience for examples and tests only. It blocks the calling thread in a busy-poll loop until the resource is available or timeout elapses. In production, prefer the async_add_* variant and drive its poll() from your own event loop rather than blocking on a single operation.

Production pattern (pseudo code)

// 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.
}

See poll_blocking on the async poller for the same caveat.

impl Aeron

pub fn async_add_exclusive_publication( &self, uri: &CStr, stream_id: i32, ) -> Result<AeronAsyncAddExclusivePublication, AeronCError>

impl Aeron

pub fn add_exclusive_publication( &self, uri: &CStr, stream_id: i32, timeout: Duration, ) -> Result<AeronExclusivePublication, AeronCError>

Blocking convenience wrapper around the async add operation.

Convenience for examples and tests only. It blocks the calling thread in a busy-poll loop until the resource is available or timeout elapses. In production, prefer the async_add_* variant and drive its poll() from your own event loop rather than blocking on a single operation.

Production pattern (pseudo code)

// 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.
}

See poll_blocking on the async poller for the same caveat.

impl Aeron

pub fn async_add_publication( &self, uri: &CStr, stream_id: i32, ) -> Result<AeronAsyncAddPublication, AeronCError>

impl Aeron

pub fn add_publication( &self, uri: &CStr, stream_id: i32, timeout: Duration, ) -> Result<AeronPublication, AeronCError>

Blocking convenience wrapper around the async add operation.

Convenience for examples and tests only. It blocks the calling thread in a busy-poll loop until the resource is available or timeout elapses. In production, prefer the async_add_* variant and drive its poll() from your own event loop rather than blocking on a single operation.

Production pattern (pseudo code)

// 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.
}

See poll_blocking on the async poller for the same caveat.

impl Aeron

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>

impl Aeron

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.

Convenience for examples and tests only. It blocks the calling thread in a busy-poll loop until the resource is available or timeout elapses. In production, prefer the async_add_* variant and drive its poll() from your own event loop rather than blocking on a single operation.

Production pattern (pseudo code)

// 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.
}

See poll_blocking on the async poller for the same caveat.

impl Aeron

pub fn new(context: &AeronContext) -> Result<Self, AeronCError>

Create a Aeron client struct and initialize from the AeronContext struct.

The given AeronContext struct will be used exclusively by the client. Do not reuse between clients.

Parameters

• context to use for initialization.

Return

0 for success and -1 for error.

pub fn fprintf( src_: &CStr, line_: u64, stream: *mut c_void, format: &CStr, ) -> Result<i32, AeronCError>

Global file writing method, allows for interposition

pub fn set_fprintf_handler( fn_: aeron_fprintf_handler_t, ) -> aeron_fprintf_handler_t

update the fprintf_handler, return previously installed handler

pub fn get_fprintf_handler() -> aeron_fprintf_handler_t

return the fprintf_handler

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.

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.

pub fn main_idle_strategy(&self, work_count: c_int)

Call the Conductor Idle Strategy.

Parameters

• work_count to pass to idle strategy.

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.

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_out to call for each label and value.

pub fn context(&self) -> AeronContext

Return the AeronContext that is in use by the given client.

Return

the AeronContext for the given client or NULL for an error.

pub fn client_id(&self) -> i64

Return the client id in use by the client.

Return

id value or -1 for an error.

pub fn next_correlation_id(&self) -> i64

Return a unique correlation id from the driver.

Return

unique correlation id or -1 for an error.

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 AeronAsyncAddPublication instance. If a publication gets created by the time cancellation happens, it will get removed.

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 AeronAsyncAddPublication instance won’t be freed.

Return

0 for success or -1 for error.

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_id of the publication to be removed.

• on_complete optional 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_clientd parameter to pass to the on_complete callback.

Return

0 for success or -1 for error.

The callback is retained by the C client; this resource keeps it alive automatically. Returns the created Handler for optional state access — safe to ignore. Closures with a matching signature are accepted directly.

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 AeronAsyncAddExclusivePublication instance. If a publication gets created by the time cancellation happens, it will get removed.

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 AeronAsyncAddExclusivePublication instance won’t be freed.

Return

0 for success or -1 for error.

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_id of the exclusive publication to be removed.

• on_complete optional 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_clientd parameter to pass to the on_complete callback.

Return

0 for success or -1 for error.

The callback is retained by the C client; this resource keeps it alive automatically. Returns the created Handler for optional state access — safe to ignore. Closures with a matching signature are accepted directly.

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 AeronAsyncAddSubscription instance. If a subscription gets created by the time cancellation happens, it will get removed.

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 AeronAsyncAddSubscription instance won’t be freed.

Return

0 for success or -1 for error.

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_id of the subscription to be removed.

• on_complete optional 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_clientd parameter to pass to the on_complete callback.

Return

0 for success or -1 for error.

The callback is retained by the C client; this resource keeps it alive automatically. Returns the created Handler for optional state access — safe to ignore. Closures with a matching signature are accepted directly.

pub fn counters_reader(&self) -> 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.

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 AeronAsyncAddCounter instance. If a counter gets created by the time cancellation happens, it will get removed.

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 AeronAsyncAddCounter instance won’t be freed.

Return

0 for success or -1 for error.

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_id of the counter to be removed.

• on_complete optional 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_clientd parameter to pass to the on_complete callback.

Return

0 for success or -1 for error.

The callback is retained by the C client; this resource keeps it alive automatically. Returns the created Handler for optional state access — safe to ignore. Closures with a matching signature are accepted directly.

pub fn add_available_counter_handler( &self, pair: &AeronAvailableCounterPair, ) -> Result<i32, AeronCError>

Add a handler to be called when a new counter becomes available.

NOTE: This function blocks until the handler is added by the client conductor thread.

Parameters

• pair holding the handler to call and a clientd to pass when called.

Return

0 for success and -1 for error

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 available.

NOTE: This function blocks until the handler is removed by the client conductor thread.

Parameters

• pair holding the handler to call and a clientd to pass when called.

Return

0 for success and -1 for error

pub fn add_unavailable_counter_handler( &self, pair: &AeronUnavailableCounterPair, ) -> Result<i32, AeronCError>

Add a handler to be called when a new counter becomes unavailable or goes away.

NOTE: This function blocks until the handler is added by the client conductor thread.

Parameters

• pair holding the handler to call and a clientd to pass when called.

Return

0 for success and -1 for error

pub fn remove_unavailable_counter_handler( &self, pair: &AeronUnavailableCounterPair, ) -> 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

• pair holding the handler to call and a clientd to pass when called.

Return

0 for success and -1 for error

pub fn add_close_handler( &self, pair: &AeronCloseClientPair, ) -> Result<i32, AeronCError>

Add a handler to be called when client is closed.

NOTE: This function blocks until the handler is added by the client conductor thread.

Parameters

• pair holding the handler to call and a clientd to pass when called.

Return

0 for success and -1 for error

pub fn remove_close_handler( &self, pair: &AeronCloseClientPair, ) -> Result<i32, AeronCError>

Remove a previously added handler to be called when client is closed.

NOTE: This function blocks until the handler is removed by the client conductor thread.

Parameters

• pair holding the handler to call and a clientd to pass when called.

Return

0 for success and -1 for error

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!!

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!!

pub fn version_major() -> Result<i32, AeronCError>

Return major version number.

Return

major version number.

pub fn version_minor() -> Result<i32, AeronCError>

Return minor version number.

Return

minor version number.

pub fn version_patch() -> Result<i32, AeronCError>

Return patch version number.

Return

patch version number.

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!!

pub fn nano_clock() -> i64

Return time in nanoseconds for machine. Is not wall clock time.

Return

nanoseconds since epoch for machine.

pub fn epoch_clock() -> i64

Return time in milliseconds since epoch. Is wall clock time.

Return

milliseconds since epoch.

pub fn is_driver_active( dirname: &CStr, timeout_ms: i64, log_func: aeron_log_func_t, ) -> bool

Determine if an aeron driver is using a given aeron directory.

Parameters

• dirname for aeron directory

• timeout_ms to use to determine activity for aeron directory

• log_func to call during activity check to log diagnostic information.

Return

true for active driver or false for no active driver.

pub fn properties_buffer_load(buffer: &CStr) -> Result<i32, AeronCError>

Load properties from a string containing name=value pairs and set appropriate environment variables for the process so that subsequent calls to aeron_driver_context_init will use those values.

Parameters

• buffer containing properties and values.

Return

0 for success and -1 for error.

pub fn properties_file_load(filename: &CStr) -> Result<i32, AeronCError>

Load properties file and set appropriate environment variables for the process so that subsequent calls to aeron_driver_context_init will use those values.

Parameters

• filename to load.

Return

0 for success and -1 for error.

pub fn properties_http_load(url: &CStr) -> Result<i32, AeronCError>

Load properties from HTTP URL and set environment variables for the process so that subsequent calls to aeron_driver_context_init will use those values.

Parameters

• url to attempt to retrieve and load.

Return

0 for success and -1 for error.

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_filename to load properties from.

Return

0 for success and -1 for error.

pub fn errcode() -> Result<i32, AeronCError>

Return current aeron error code (errno) for calling thread.

Return

aeron error code for calling thread.

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!!

pub fn default_path(path: &mut [u8]) -> Result<i32, AeronCError>

Get the default path used by the Aeron media driver.

Parameters

• path buffer to store the path.

• path_length space 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 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 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 set_errno(errcode: c_int)

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 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>

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!!

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

pub fn open_file_append(path: &CStr) -> *mut c_void

Opens or creates a new file in append mode. Will use 0644 permissions on Linux/Mac and default on Windows.

Parameters

• path to the location on the file system.

Return

A FILE* pointer as a void* to reduce type dependencies. Returns null on failure.

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 temp_dir(dir_template: &CStr) -> &'static str

Returns a new temporary directory, allocates the string which needs to be freed by the user.

Parameters

• dir_template to be used to create the temporary directory.

Return

the new temporary path. SAFETY: this is static for performance reasons, so you should not store this without copying it!!

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

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

impl Aeron

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 fully usable. The C close runs when the final reference (child or clone) is released.

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.

impl Aeron

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 — error handlers, driver timeout, idle strategy — build the AeronContext yourself and use Aeron::new.

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.

pub fn connect_dir(dir: &str) -> Result<Aeron, AeronCError>

Connect to a media driver in dir. Equivalent to Self::connect(Some(dir)).

impl Aeron

pub fn new_blocking( context: &AeronContext, timeout: Duration, ) -> Result<Self, AeronCError>

Trait Implementations

impl Clone for Aeron

fn clone(&self) -> Aeron

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Aeron

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for Aeron

type Target = aeron_stct

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl From<&Aeron> for *mut aeron_t

fn from(value: &Aeron) -> Self

Converts to this type from the input type.

impl From<*const aeron_stct> for Aeron

fn from(value: *const aeron_t) -> Self

Converts to this type from the input type.

impl From<*mut aeron_stct> for Aeron

fn from(value: *mut aeron_t) -> Self

Converts to this type from the input type.

impl From<Aeron> for *mut aeron_t

fn from(value: Aeron) -> Self

Converts to this type from the input type.

impl From<Aeron> for aeron_t

fn from(value: Aeron) -> Self

Converts to this type from the input type.

impl From<aeron_stct> for Aeron

fn from(value: aeron_t) -> Self

Converts to this type from the input type.