Method step

server/src/networking.rs:93–310

Handle networking events.

(&mut self, t: u64, interests: &HashMap<String, HashSet<Token>>)

    /// Handle networking events.
    pub fn step(&mut self, t: u64, interests: &HashMap<String, HashSet<Token>>) {
        // We mustn't timeout here, we are not in charge of blocking.
        self.poll
            .poll(&mut self.events, Some(Duration::from_millis(0)))
            .expect("failed to poll I/O events");

        for event in self.events.iter() {
            trace!("[IO] recv event on {:?}", event.token());

            match event.token() {
                SERVER => {
                    if event.readiness().is_readable() {
                        // new connection arrived on the server socket
                        match self.server_socket.accept() {
                            Err(err) => error!("[IO] error while accepting connection {:?}", err),
                            Ok((socket, addr)) => {
                                let token = {
                                    let entry = self.connections.vacant_entry();
                                    let token = Token(entry.key());
                                    let connection_id = self.next_connection_id;

                                    self.next_connection_id =
                                        self.next_connection_id.wrapping_add(1);

                                    entry.insert(Connection::new(
                                        token,
                                        socket,
                                        self.ws_settings,
                                        connection_id,
                                    ));

                                    token
                                };

                                info!("[IO] new tcp connection from {} (token {:?})", addr, token);

                                let conn = &mut self.connections[token.into()];

                                conn.as_server().unwrap();

                                self.poll
                                    .register(
                                        conn.socket(),
                                        conn.token(),
                                        conn.events(),
                                        PollOpt::edge() | PollOpt::oneshot(),
                                    )
                                    .unwrap();
                            }
                        }
                    }
                }
                RESULTS => {
                    while let Ok(out) = self.recv.try_recv() {
                        let tokens: Box<dyn Iterator<Item = Token>> = match &out {
                            &Output::QueryDiff(ref name, ref results) => {
                                info!("[IO] {} {} results", name, results.len());