Struct MessageProxy

pub struct MessageProxy {
    pub(crate) _queue_task_handle: JoinHandle<()>,
    pub(crate) event_tx: Sender<Event>,
}

Fields

_queue_task_handle: JoinHandle<()>

event_tx: Sender<Event>

Implementations

impl MessageProxy

pub fn new(server_memory_limit: MemoryLimit) -> Self

pub(crate) fn new_with_recv( server_memory_limit: MemoryLimit, ) -> (Self, Receiver<LogMsgProto>, Receiver<TableMsgProto>)

pub(crate) async fn push_msg(&self, msg: LogMsgProto)

pub(crate) async fn push_table(&self, table: TableMsgProto)

pub(crate) async fn new_client_message_stream( &self, ) -> Pin<Box<dyn Stream<Item = Result<ReadMessagesResponse>> + Send>>

pub(crate) async fn new_client_table_stream( &self, ) -> Pin<Box<dyn Stream<Item = Result<ReadTablesResponse>> + Send>>

Trait Implementations

impl MessageProxyService for MessageProxy

type ReadMessagesStream = Pin<Box<dyn Stream<Item = Result<ReadMessagesResponse, Status>> + Send>>

Server streaming response type for the ReadMessages method.

type ReadTablesStream = Pin<Box<dyn Stream<Item = Result<ReadTablesResponse, Status>> + Send>>

Server streaming response type for the ReadTables method.

fn write_messages<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<WriteMessagesRequest>>, ) -> Pin<Box<dyn Future<Output = Result<Response<WriteMessagesResponse>>> + Send + 'async_trait>>

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

TODO(jan): Would it be more efficient to send a “message batch” instead of individual messages? It may allow us to amortize the overhead of the gRPC protocol.

fn read_messages<'life0, 'async_trait>( &'life0 self, __arg1: Request<ReadMessagesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::ReadMessagesStream>>> + Send + 'async_trait>>

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

fn write_table<'life0, 'async_trait>( &'life0 self, request: Request<WriteTableRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<WriteTableResponse>>> + Send + 'async_trait>>

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

fn read_tables<'life0, 'async_trait>( &'life0 self, __arg1: Request<ReadTablesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::ReadTablesStream>>> + Send + 'async_trait>>

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