Struct EventLoop

pub(crate) struct EventLoop {
    pub(crate) server_memory_limit: MemoryLimit,
    pub(crate) broadcast_log_tx: Sender<LogMsg>,
    pub(crate) broadcast_table_tx: Sender<TableMsgProto>,
    pub(crate) event_rx: Receiver<Event>,
    pub(crate) ordered_message_queue: VecDeque<Msg>,
    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_log_tx: Sender<LogMsg>

New log messages are broadcast to all clients.

broadcast_table_tx: Sender<TableMsgProto>

New table messages are broadcast to all clients.

event_rx: Receiver<Event>

Channel for incoming events.

ordered_message_queue: VecDeque<Msg>

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

ordered_message_bytes: u64

Total size of ordered_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>, broadcast_log_tx: Sender<LogMsgProto>, broadcast_table_tx: Sender<TableMsgProto>, ) -> Self

pub(crate) async fn run_in_place(self)

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

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

pub(crate) fn handle_table(&mut self, table: TableMsgProto)

pub(crate) fn gc_if_using_too_much_ram(&mut self)