Struct Session 

pub struct Session {
    pub session: Weak<SessionController>,
    pub rx: RwLock<AppChannelReceiver>,
}

Session context for language bindings (UniFFI-compatible)

Wraps the session context with proper async access patterns for message reception. Provides both synchronous (blocking) and asynchronous methods for FFI compatibility.

Fields

session: Weak<SessionController>

Weak reference to the underlying session

rx: RwLock<AppChannelReceiver>

Message receiver wrapped in RwLock for concurrent access

Implementations

impl Session

pub fn new(ctx: SlimSession) -> Self

Create a new Session from a Session and runtime

pub fn runtime(&self) -> &'static Runtime

Get the runtime (for internal use)

impl Session

pub async fn publish_internal( &self, name: &SlimName, fanout: u32, blob: Vec<u8>, conn_out: Option<u64>, payload_type: Option<String>, metadata: Option<HashMap<String, String>>, ) -> Result<SlimCompletionHandle, SessionError>

Publish a message through this session (internal API for language bindings)

This is the low-level publish method that takes SlimName directly. Use publish() or publish_with_params() for FFI-compatible APIs.

pub async fn publish_to_internal( &self, message_ctx: &MessageContext, blob: Vec<u8>, payload_type: Option<String>, metadata: Option<HashMap<String, String>>, ) -> Result<SlimCompletionHandle, SessionError>

Publish a message as a reply (internal API for language bindings)

This is the low-level publish_to method that takes MessageContext reference. Use publish_to() for FFI-compatible API.

pub async fn invite_internal( &self, destination: &SlimName, ) -> Result<SlimCompletionHandle, SessionError>

Invite a peer to join this session (internal API for language bindings)

This is the low-level invite method that takes SlimName reference. Use invite() for FFI-compatible API with auto-wait.

pub async fn remove_internal( &self, destination: &SlimName, ) -> Result<SlimCompletionHandle, SessionError>

Remove a peer from this session (internal API for language bindings)

This is the low-level remove method that takes SlimName reference. Use remove() for FFI-compatible API with auto-wait.

pub async fn get_session_message( &self, timeout: Option<Duration>, ) -> Result<(MessageContext, Vec<u8>), SessionError>

Receive a message from this session with optional timeout

impl Session

pub fn publish( &self, data: Vec<u8>, payload_type: Option<String>, metadata: Option<HashMap<String, String>>, ) -> Result<Arc<CompletionHandle>, SlimError>

Publish a message to the session’s destination (blocking version)

Returns a completion handle that can be awaited to ensure the message was delivered.

Arguments

• data - The message payload bytes
• payload_type - Optional content type identifier
• metadata - Optional key-value metadata pairs

Returns

• Ok(CompletionHandle) - Handle to await delivery confirmation
• Err(SlimError) - If publishing fails

Example

let completion = session.publish(data, None, None)?;
completion.wait()?; // Blocks until message is delivered

pub async fn publish_async( &self, data: Vec<u8>, payload_type: Option<String>, metadata: Option<HashMap<String, String>>, ) -> Result<Arc<CompletionHandle>, SlimError>

Publish a message to the session’s destination (async version)

Returns a completion handle that can be awaited to ensure the message was delivered.

pub fn publish_and_wait( &self, data: Vec<u8>, payload_type: Option<String>, metadata: Option<HashMap<String, String>>, ) -> Result<(), SlimError>

Publish a message and wait for completion (blocking version)

This method publishes a message and blocks until the delivery completes.

pub async fn publish_and_wait_async( &self, data: Vec<u8>, payload_type: Option<String>, metadata: Option<HashMap<String, String>>, ) -> Result<(), SlimError>

Publish a message and wait for completion (async version)

This method publishes a message and waits until the delivery completes.

pub fn publish_to( &self, message_context: MessageContext, data: Vec<u8>, payload_type: Option<String>, metadata: Option<HashMap<String, String>>, ) -> Result<Arc<CompletionHandle>, SlimError>

Publish a reply message to the originator of a received message (blocking version for FFI)

This method uses the routing information from a previously received message to send a reply back to the sender. This is the preferred way to implement request/reply patterns.

Returns a completion handle that can be awaited to ensure the message was delivered.

Arguments

• message_context - Context from a message received via get_message()
• data - The reply payload bytes
• payload_type - Optional content type identifier
• metadata - Optional key-value metadata pairs

Returns

• Ok(CompletionHandle) - Handle to await delivery confirmation
• Err(SlimError) - If publishing fails

pub async fn publish_to_async( &self, message_context: MessageContext, data: Vec<u8>, payload_type: Option<String>, metadata: Option<HashMap<String, String>>, ) -> Result<Arc<CompletionHandle>, SlimError>

Publish a reply message (async version)

Returns a completion handle that can be awaited to ensure the message was delivered.

pub fn publish_to_and_wait( &self, message_context: MessageContext, data: Vec<u8>, payload_type: Option<String>, metadata: Option<HashMap<String, String>>, ) -> Result<(), SlimError>

Publish a reply message and wait for completion (blocking version)

This method publishes a reply to a received message and blocks until the delivery completes.

pub async fn publish_to_and_wait_async( &self, message_context: MessageContext, data: Vec<u8>, payload_type: Option<String>, metadata: Option<HashMap<String, String>>, ) -> Result<(), SlimError>

Publish a reply message and wait for completion (async version)

This method publishes a reply to a received message and waits until the delivery completes.

pub fn publish_with_params( &self, destination: Arc<Name>, fanout: u32, data: Vec<u8>, connection_out: Option<u64>, payload_type: Option<String>, metadata: Option<HashMap<String, String>>, ) -> Result<(), SlimError>

Low-level publish with full control over all parameters (blocking version for FFI)

This is an advanced method that provides complete control over routing and delivery. Most users should use publish() or publish_to() instead.

Arguments

• destination - Target name to send to
• fanout - Number of copies to send (for multicast)
• data - The message payload bytes
• connection_out - Optional specific connection ID to use
• payload_type - Optional content type identifier
• metadata - Optional key-value metadata pairs

pub async fn publish_with_params_async( &self, destination: Arc<Name>, fanout: u32, data: Vec<u8>, connection_out: Option<u64>, payload_type: Option<String>, metadata: Option<HashMap<String, String>>, ) -> Result<(), SlimError>

Low-level publish with full control (async version)

pub fn get_message( &self, timeout: Option<Duration>, ) -> Result<ReceivedMessage, SlimError>

Receive a message from the session (blocking version for FFI)

Arguments

• timeout - Optional timeout duration

Returns

• Ok(ReceivedMessage) - Message with context and payload bytes
• Err(SlimError) - If the receive fails or times out

pub async fn get_message_async( &self, timeout: Option<Duration>, ) -> Result<ReceivedMessage, SlimError>

Receive a message from the session (async version)

pub fn invite( &self, participant: Arc<Name>, ) -> Result<Arc<CompletionHandle>, SlimError>

Invite a participant to the session (blocking version)

Returns a completion handle that can be awaited to ensure the invitation completes.

pub async fn invite_async( &self, participant: Arc<Name>, ) -> Result<Arc<CompletionHandle>, SlimError>

Invite a participant to the session (async version)

Returns a completion handle that can be awaited to ensure the invitation completes.

pub fn invite_and_wait(&self, participant: Arc<Name>) -> Result<(), SlimError>

Invite a participant and wait for completion (blocking version)

This method invites a participant and blocks until the invitation completes.

pub async fn invite_and_wait_async( &self, participant: Arc<Name>, ) -> Result<(), SlimError>

Invite a participant and wait for completion (async version)

This method invites a participant and waits until the invitation completes.

pub fn remove( &self, participant: Arc<Name>, ) -> Result<Arc<CompletionHandle>, SlimError>

Remove a participant from the session (blocking version)

Returns a completion handle that can be awaited to ensure the removal completes.

pub async fn remove_async( &self, participant: Arc<Name>, ) -> Result<Arc<CompletionHandle>, SlimError>

Remove a participant from the session (async version)

Returns a completion handle that can be awaited to ensure the removal completes.

pub fn remove_and_wait(&self, participant: Arc<Name>) -> Result<(), SlimError>

Remove a participant and wait for completion (blocking version)

This method removes a participant and blocks until the removal completes.

pub async fn remove_and_wait_async( &self, participant: Arc<Name>, ) -> Result<(), SlimError>

Remove a participant and wait for completion (async version)

This method removes a participant and waits until the removal completes.

pub fn destination(&self) -> Result<Name, SlimError>

Get the destination name for this session

pub fn source(&self) -> Result<Name, SlimError>

Get the source name for this session

pub fn session_id(&self) -> Result<u32, SlimError>

Get the session ID

pub fn session_type(&self) -> Result<SessionType, SlimError>

Get the session type (PointToPoint or Group)

pub fn is_initiator(&self) -> Result<bool, SlimError>

Check if this session is the initiator

pub fn metadata(&self) -> Result<HashMap<String, String>, SlimError>

Get the session metadata

pub fn config(&self) -> Result<SessionConfig, SlimError>

Get the session configuration

pub async fn participants_list_async(&self) -> Result<Vec<Arc<Name>>, SlimError>

Get list of participants in the session

pub fn participants_list(&self) -> Result<Vec<Arc<Name>>, SlimError>

Get list of participants in the session (blocking version for FFI)

Trait Implementations

impl<UT> LiftRef<UT> for Session

type LiftType = Arc<Session>

impl<UT> LowerError<UT> for Session

fn lower_error(obj: Self) -> RustBuffer

Lower this value for scaffolding function return

impl<UT> LowerReturn<UT> for Session

type ReturnType = <Arc<Session> as LowerReturn<UniFfiTag>>::ReturnType

The type that should be returned by scaffolding functions for this type.

fn lower_return(obj: Self) -> Result<Self::ReturnType, RustCallError>

Lower the return value from an scaffolding call

fn handle_failed_lift( error: LiftArgsError, ) -> Result<Self::ReturnType, RustCallError>

Lower the return value for failed argument lifts

impl<UT> TypeId<UT> for Session

const TYPE_ID_META: MetadataBuffer