Struct TcpBackend 

pub struct TcpBackend(pub ActorHandle<TcpManagerActor>);

Wrapper around ActorHandle<TcpManagerActor> that moves the TCP data-plane (chunked reads/writes) off the actor loop while keeping buffer resolution serialized through actor messages.

Because submit logic now runs outside the actor loop, same-process messages no longer deadlock — the actor loop is free to handle WriteChunk/ReadChunk messages.

Tuple Fields

0: ActorHandle<TcpManagerActor>

Methods from Deref<Target = ActorHandle<TcpManagerActor>>

pub fn actor_addr(&self) -> &ActorAddr

The ActorAddr of the actor represented by this handle.

pub fn drain_and_stop(&self, reason: &str) -> Result<(), ActorError>

Signal the actor to drain its current messages and then stop.

pub fn stop(&self, reason: &str) -> Result<(), ActorError>

Signal the actor to stop without draining ordinary queued work first.

pub fn kill(&self, reason: &str) -> Result<(), ActorError>

Signal the actor to terminate immediately.

pub fn status(&self) -> Receiver<ActorStatus>

A watch that observes the lifecycle state of the actor.

pub fn port<M>(&self) -> PortHandle<M>

where M: Message, A: Handler<M>,

Return a port for the provided message type handled by the actor.

pub fn try_post<C, M>( &self, cx: &C, message: M, ) -> Result<(), MailboxSenderError>

where C: Actor, M: Message, A: Handler<M>,

Post message to this actor’s handler port for M, returning an error if delivery fails (the actor has stopped, its mailbox is closed, or the underlying channel is disconnected). Unlike Endpoint::post, the caller observes the failure instead of having it reported through the actor’s lost-message channel.

pub fn bind<R>(&self) -> ActorRef<R>

where R: Binds<A>,

TEMPORARY: bind… TODO: we shoudl also have a default binding(?)

Trait Implementations

impl Clone for TcpBackend

fn clone(&self) -> TcpBackend

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TcpBackend

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

Formats the value using the given formatter.

impl Deref for TcpBackend

type Target = ActorHandle<TcpManagerActor>

The resulting type after dereferencing.

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

Dereferences the value.

impl RdmaBackend for TcpBackend

fn available() -> bool

TCP is available when fallback is enabled.

fn register_remote_buffer<'life0, 'life1, 'async_trait>( &'life0 self, _cx: &'life1 (impl 'async_trait + Actor + Send + Sync), _remote_buf_id: usize, _local: KeepaliveLocalMemory, ) -> Pin<Box<dyn Future<Output = Result<ActorRef<TcpManagerActor>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

TCP needs no per-buffer registration.

fn submit<'life0, 'life1, 'async_trait>( &'life0 self, cx: &'life1 (impl 'async_trait + Actor + Send + Sync), ops: Vec<RdmaOp>, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Submit a batch of RDMA operations over TCP.

Each op is executed directly — sending chunked write/read messages to the remote TcpManagerActor.

type RemoteBackendContext = ActorRef<TcpManagerActor>

Serializable per-buffer context carried on the wire.

type TransportInfo = ()

Backend-specific transport details (e.g. a cffi struct with raw ibverbs handles for GPU-initiated RDMA).

fn transport_level(&self) -> RdmaTransportLevel

The transport level this backend provides.

fn transport_info(&self) -> Option<Self::TransportInfo>

Low-level transport details for direct control over RDMA operations (e.g. from a GPU kernel).

fn spawn<'life0, 'life1, 'async_trait>( cx: &'life0 (impl 'async_trait + Actor + Send + Sync), _config: &'life1 RdmaConfig, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Spawn the backend’s actor(s) as children of cx and return its handle.

fn release_buffer<'life0, 'life1, 'async_trait>( &'life0 self, _cx: &'life1 (impl 'async_trait + Actor + Send + Sync), _remote_buf_id: usize, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Release a buffer registration by id.