Struct ConnectionHandlerContextWrapper 

pub struct ConnectionHandlerContextWrapper { /* private fields */ }

Request handler context - provides access to the channel for a specific connection.

ConnectionHandlerContextWrapper is the execution context passed to request processors. It encapsulates the channel associated with the incoming request, allowing handlers to:

• Send responses: Via write() or write_ref()
• Access connection metadata: Remote address, connection state
• Perform advanced operations: Direct connection access if needed

Design Rationale

• Thin wrapper: Delegates most operations to the underlying Channel
• Hash/Eq based on channel: Contexts for the same channel are equal
• Wrapped in ArcMut: Shared across async tasks, enables interior mutability

Naming Note

The “Wrapper” suffix indicates this is the concrete type wrapped by the ConnectionHandlerContext type alias. It’s rarely used directly - prefer using the type alias in function signatures.

Implementations

impl ConnectionHandlerContextWrapper

pub fn new(channel: Channel) -> Self

Creates a new handler context wrapping the given channel.

Arguments

• channel - The channel associated with this handler invocation

Returns

A new context ready for use by request processors

pub fn connection_ref(&self) -> &Connection

Gets an immutable reference to the underlying connection.

Returns

Immutable reference to the Connection for inspection

Use Case

Checking connection health, reading connection ID, etc.

pub fn connection_mut(&mut self) -> &mut Connection

Gets a mutable reference to the underlying connection.

Returns

Mutable reference to the Connection for advanced I/O

Use Case

Direct send/receive operations bypassing channel abstractions

pub async fn write_response(&mut self, cmd: RemotingCommand)

Sends a response command back to the client (consumes command).

This is the primary method for responding to requests. Errors are logged but not propagated to allow handlers to continue processing.

Arguments

• cmd - The response command to send (consumed)

Behavior

• Success: Command encoded and sent
• Error: Logged at ERROR level, method returns normally

Example

async fn handle_request(ctx: &mut ConnectionHandlerContext, request: RemotingCommand) {
    let response = RemotingCommand::create_response_command()
        .set_opaque(request.opaque());
    ctx.write(response).await;
}

pub async fn write_response_ref(&mut self, cmd: &mut RemotingCommand)

Sends a response command back to the client (borrows command).

Similar to write_response, but borrows the command instead of consuming it. Use when the caller needs to retain ownership of the command.

Arguments

• cmd - Mutable reference to the response command to send

Behavior

• Success: Command encoded and sent
• Error: Logged at ERROR level, method returns normally

Note

The command’s body may be consumed during sending (take_body()).

pub async fn write(&mut self, cmd: RemotingCommand)

👎Deprecated since 0.6.0: Use write_response() instead

Legacy alias for write_response() - kept for backward compatibility.

Deprecated

Use write_response() for clearer semantics.

pub async fn write_ref(&mut self, cmd: &mut RemotingCommand)

👎Deprecated since 0.6.0: Use write_response_ref() instead

Legacy alias for write_response_ref() - kept for backward compatibility.

Deprecated

Use write_response_ref() for clearer semantics.

pub fn channel(&self) -> &Channel

Gets an immutable reference to the channel.

Returns

Immutable reference to the Channel

Use Case

Accessing channel metadata (ID, addresses, etc.)

pub fn channel_mut(&mut self) -> &mut Channel

Gets a mutable reference to the channel.

Returns

Mutable reference to the Channel

Use Case

Advanced channel operations (modify addresses, access inner state)

pub fn remote_address(&self) -> SocketAddr

Gets the remote peer’s socket address.

Returns

Socket address of the remote peer

Use Case

Logging, authorization checks, rate limiting by IP

Trait Implementations

impl AsMut<ConnectionHandlerContextWrapper> for ConnectionHandlerContextWrapper

fn as_mut(&mut self) -> &mut ConnectionHandlerContextWrapper

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<ConnectionHandlerContextWrapper> for ConnectionHandlerContextWrapper

fn as_ref(&self) -> &ConnectionHandlerContextWrapper

Converts this type into a shared reference of the (usually inferred) input type.

impl Hash for ConnectionHandlerContextWrapper

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ConnectionHandlerContextWrapper

fn eq(&self, other: &ConnectionHandlerContextWrapper) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ConnectionHandlerContextWrapper

impl StructuralPartialEq for ConnectionHandlerContextWrapper