Struct Aeron

Source

pub struct Aeron { /* private fields */ }

Implementations§

Source §

impl Aeron

Source

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 C close for the resulting resource (e.g. aeron_subscription_close) is asynchronous — the conductor thread may still invoke the handler’s callback (e.g. on_available_image) after close()/drop has already returned on the calling thread. Releasing the handler’s value immediately on close would risk a use-after-free from that still-in-flight callback.

To make this safe without requiring the caller to track it, this method stores a clone of the owning Aeron client as a dependency on the resource being created — which transitively keeps every Handler clone already registered as a dependency of that resource alive for as long as the client itself lives, regardless of when the resource closes. No manual release() call is needed.

This differs from the Aeron C++ wrapper, which instead frees the handler as the final step of on_cmd_close_subscription on the conductor thread — i.e. it ties the handler’s lifetime to the close completing, not to the client. Rusteron’s approach is simpler and avoids needing a conductor-side hook, but it means handler dependencies accumulate on the client’s dependency list for the client’s lifetime (they are small Arc clones, one per call, and are only dropped when the client itself drops).

Source §

impl Aeron

Source

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.

Source §

impl Aeron

Source

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 C close for the resulting resource (e.g. aeron_subscription_close) is asynchronous — the conductor thread may still invoke the handler’s callback (e.g. on_available_image) after close()/drop has already returned on the calling thread. Releasing the handler’s value immediately on close would risk a use-after-free from that still-in-flight callback.

To make this safe without requiring the caller to track it, this method stores a clone of the owning Aeron client as a dependency on the resource being created — which transitively keeps every Handler clone already registered as a dependency of that resource alive for as long as the client itself lives, regardless of when the resource closes. No manual release() call is needed.

This differs from the Aeron C++ wrapper, which instead frees the handler as the final step of on_cmd_close_subscription on the conductor thread — i.e. it ties the handler’s lifetime to the close completing, not to the client. Rusteron’s approach is simpler and avoids needing a conductor-side hook, but it means handler dependencies accumulate on the client’s dependency list for the client’s lifetime (they are small Arc clones, one per call, and are only dropped when the client itself drops).

Source §

impl Aeron

Source

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.

Source §

impl Aeron

Source

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 C close for the resulting resource (e.g. aeron_subscription_close) is asynchronous — the conductor thread may still invoke the handler’s callback (e.g. on_available_image) after close()/drop has already returned on the calling thread. Releasing the handler’s value immediately on close would risk a use-after-free from that still-in-flight callback.

To make this safe without requiring the caller to track it, this method stores a clone of the owning Aeron client as a dependency on the resource being created — which transitively keeps every Handler clone already registered as a dependency of that resource alive for as long as the client itself lives, regardless of when the resource closes. No manual release() call is needed.

This differs from the Aeron C++ wrapper, which instead frees the handler as the final step of on_cmd_close_subscription on the conductor thread — i.e. it ties the handler’s lifetime to the close completing, not to the client. Rusteron’s approach is simpler and avoids needing a conductor-side hook, but it means handler dependencies accumulate on the client’s dependency list for the client’s lifetime (they are small Arc clones, one per call, and are only dropped when the client itself drops).

Source §

impl Aeron

Source

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.

Source §

impl Aeron

Source

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 C close for the resulting resource (e.g. aeron_subscription_close) is asynchronous — the conductor thread may still invoke the handler’s callback (e.g. on_available_image) after close()/drop has already returned on the calling thread. Releasing the handler’s value immediately on close would risk a use-after-free from that still-in-flight callback.

To make this safe without requiring the caller to track it, this method stores a clone of the owning Aeron client as a dependency on the resource being created — which transitively keeps every Handler clone already registered as a dependency of that resource alive for as long as the client itself lives, regardless of when the resource closes. No manual release() call is needed.

This differs from the Aeron C++ wrapper, which instead frees the handler as the final step of on_cmd_close_subscription on the conductor thread — i.e. it ties the handler’s lifetime to the close completing, not to the client. Rusteron’s approach is simpler and avoids needing a conductor-side hook, but it means handler dependencies accumulate on the client’s dependency list for the client’s lifetime (they are small Arc clones, one per call, and are only dropped when the client itself drops).

Source §

impl Aeron

Source

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.

Source §

impl Aeron

Source

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.

Source

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

Global file writing method, allows for interposition

Source

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

update the fprintf_handler, return previously installed handler

Source

pub fn get_fprintf_handler() -> aeron_fprintf_handler_t

return the fprintf_handler

Source

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.

Source

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.

Source

pub fn main_idle_strategy(&self, work_count: c_int)

Call the Conductor Idle Strategy.

§Parameters

work_count to pass to idle strategy.

Source

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.

Source

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.

Source

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.

Source

pub fn client_id(&self) -> i64

Return the client id in use by the client.

§Return

id value or -1 for an error.

Source

pub fn next_correlation_id(&self) -> i64

Return a unique correlation id from the driver.

§Return

unique correlation id or -1 for an error.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Return major version number.

§Return

major version number.

Source

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

Return minor version number.

§Return

minor version number.

Source

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

Return patch version number.

§Return

patch version number.

Source

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

Source

pub fn nano_clock() -> i64

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

§Return

nanoseconds since epoch for machine.

Source

pub fn epoch_clock() -> i64

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

§Return

milliseconds since epoch.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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

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

§Return

aeron error code for calling thread.

Source

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

Source

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.

Source

pub fn format_number_to_locale( value: c_longlong, buffer: &mut [u8], ) -> *mut c_char

Source

pub fn format_to_hex(str_: &mut [u8], data: &[u8])

Source

pub fn digit_count(value: u32) -> Result<i32, AeronCError>

Source

pub fn set_errno(errcode: c_int)

Source

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

Source

pub fn err_set( errcode: c_int, function: &CStr, filename: &CStr, line_number: c_int, format: &CStr, )

Source

pub fn err_append( function: &CStr, filename: &CStr, line_number: c_int, format: &CStr, )

Source

pub fn err_clear()

Source

pub fn free(ptr: *mut c_void)

Source

pub fn res_header_entry_length( res: *mut c_void, remaining: usize, ) -> Result<i32, AeronCError>

Source

pub fn logbuffer_check_term_length(term_length: u64) -> Result<i32, AeronCError>

Source

pub fn logbuffer_check_page_size(page_size: u64) -> Result<i32, AeronCError>

Source

pub fn is_directory(path: &CStr) -> Result<i32, AeronCError>

Source

pub fn delete_directory(directory: &CStr) -> Result<i32, AeronCError>

Source

pub fn mkdir_recursive( pathname: &CStr, permission: c_int, ) -> Result<i32, AeronCError>

Source

pub fn msync(addr: *mut c_void, length: usize) -> Result<i32, AeronCError>

Source

pub fn delete_file(path: &CStr) -> Result<i32, AeronCError>

Source

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

Source

pub fn tmpdir(path: &mut [u8]) -> &'static str

SAFETY: this is static for performance reasons, so you should not store this without copying it!!

Source

pub fn file_exists(path: &CStr) -> bool

Source

pub fn ftell(stream: *mut c_void) -> i64

Source

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.

Source

pub fn file_length(path: &CStr) -> i64

Source

pub fn usable_fs_space(path: &CStr) -> u64

Source

pub fn usable_fs_space_disabled(path: &CStr) -> u64

Source

pub fn ipc_publication_location( dst: &mut [u8], aeron_dir: &CStr, correlation_id: i64, ) -> Result<i32, AeronCError>

Source

pub fn network_publication_location( dst: &mut [u8], aeron_dir: &CStr, correlation_id: i64, ) -> Result<i32, AeronCError>

Source

pub fn temp_filename(filename: &mut [u8]) -> usize

Source

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

Source

pub fn file_resolve( parent: &CStr, child: &CStr, buffer: &mut [u8], ) -> Result<i32, AeronCError>

Source

pub fn thread_set_name(name: &CStr) -> Result<i32, AeronCError>

Source

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

Source

pub fn nano_sleep(nanoseconds: u64)

Source

pub fn micro_sleep(microseconds: c_uint)

Source

pub fn thread_set_affinity( name: &CStr, cpu_affinity_no: u8, ) -> Result<i32, AeronCError>

Source

pub fn thread_get_affinity(cpu_affinity: *mut u8) -> Result<i32, AeronCError>

Source

pub fn mutex_init(mutex: *mut aeron_mutex_t) -> Result<i32, AeronCError>

Source

pub fn mutex_destroy(mutex: *mut aeron_mutex_t) -> Result<i32, AeronCError>

Source

pub fn mutex_lock(mutex: *mut aeron_mutex_t) -> Result<i32, AeronCError>

Source

pub fn mutex_unlock(mutex: *mut aeron_mutex_t) -> Result<i32, AeronCError>

Source

pub fn agent_on_start_load(name: &CStr) -> aeron_agent_on_start_func_t

Source

pub fn get_inner(&self) -> *mut aeron_t

Source

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.

Source

pub fn get_inner_ref(&self) -> &aeron_t

Source §

impl Aeron

Source

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.

Source

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

Source

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.

Source