Struct re_grpc_server::EventLoop

pub(crate) struct EventLoop {
    pub(crate) server_memory_limit: MemoryLimit,
    pub(crate) broadcast_tx: Sender<LogMsg>,
    pub(crate) event_rx: Receiver<Event>,
    pub(crate) ordered_message_queue: VecDeque<LogMsg>,
    pub(crate) ordered_message_bytes: u64,
    pub(crate) persistent_message_queue: VecDeque<LogMsg>,
}

Main event loop for the server, which runs in its own task.

Handles message history, and broadcasts messages to clients.

Fields

server_memory_limit: MemoryLimit

broadcast_tx: Sender<LogMsg>

New messages are broadcast to all clients.

event_rx: Receiver<Event>

Channel for incoming events.

ordered_message_queue: VecDeque<LogMsg>

Messages stored in order of arrival, and garbage collected if the server hits the memory limit.

ordered_message_bytes: u64

Total size of temporal_message_queue in bytes.

persistent_message_queue: VecDeque<LogMsg>

Messages potentially out of order with the rest of the message stream. These are never garbage collected.

Implementations

impl EventLoop

pub(crate) fn new( server_memory_limit: MemoryLimit, event_rx: Receiver<Event>, ) -> Self

pub(crate) async fn run_in_place(self)

pub(crate) fn handle_new_client( &self, channel: Sender<(Vec<LogMsgProto>, Receiver<LogMsgProto>)>, )

pub(crate) fn handle_msg(&mut self, msg: LogMsgProto)

pub(crate) fn gc_if_using_too_much_ram(&mut self)