rust/hedgewars-server/src/server/network.rs
changeset 14696 8a45c90f4580
parent 14693 6a2e13e36b7f
child 14697 f64e21f164a5
equal deleted inserted replaced
14695:216d39de1a44 14696:8a45c90f4580
   328         entry.insert(client);
   328         entry.insert(client);
   329 
   329 
   330         client_id
   330         client_id
   331     }
   331     }
   332 
   332 
   333     fn flush_server_messages(&mut self, mut response: handlers::Response) {
   333     fn flush_server_messages(&mut self, mut response: handlers::Response, poll: &Poll) {
   334         debug!("{} pending server messages", response.len());
   334         debug!("{} pending server messages", response.len());
   335         let output = response.extract_messages(&mut self.server);
   335         let output = response.extract_messages(&mut self.server);
   336         for (clients, message) in output {
   336         for (clients, message) in output {
   337             debug!("Message {:?} to {:?}", message, clients);
   337             debug!("Message {:?} to {:?}", message, clients);
   338             let msg_string = message.to_raw_protocol();
   338             let msg_string = message.to_raw_protocol();
   342                     self.pending
   342                     self.pending
   343                         .insert((client_id, NetworkClientState::NeedsWrite));
   343                         .insert((client_id, NetworkClientState::NeedsWrite));
   344                 }
   344                 }
   345             }
   345             }
   346         }
   346         }
       
   347 
       
   348         for client_id in response.extract_removed_clients() {
       
   349             self.deregister_client(poll, client_id);
       
   350         }
   347     }
   351     }
   348 
   352 
   349     fn create_client_socket(&self, socket: TcpStream) -> io::Result<ClientSocket> {
   353     fn create_client_socket(&self, socket: TcpStream) -> io::Result<ClientSocket> {
   350         #[cfg(not(feature = "tls-connections"))]
   354         #[cfg(not(feature = "tls-connections"))]
   351         {
   355         {
   379         let mut response = handlers::Response::new(client_id);
   383         let mut response = handlers::Response::new(client_id);
   380 
   384 
   381         handlers::handle_client_accept(&mut self.server, client_id, &mut response);
   385         handlers::handle_client_accept(&mut self.server, client_id, &mut response);
   382 
   386 
   383         if !response.is_empty() {
   387         if !response.is_empty() {
   384             self.flush_server_messages(response);
   388             self.flush_server_messages(response, poll);
   385         }
   389         }
   386 
   390 
   387         Ok(())
   391         Ok(())
   388     }
   392     }
   389 
   393 
   436                 "Error while reading from client socket",
   440                 "Error while reading from client socket",
   437             )?,
   441             )?,
   438         }
   442         }
   439 
   443 
   440         if !response.is_empty() {
   444         if !response.is_empty() {
   441             self.flush_server_messages(response);
   445             self.flush_server_messages(response, poll);
   442         }
       
   443 
       
   444         if !self.server.removed_clients.is_empty() {
       
   445             let ids: Vec<_> = self.server.removed_clients.drain(..).collect();
       
   446             for client_id in ids {
       
   447                 self.deregister_client(poll, client_id);
       
   448             }
       
   449         }
   446         }
   450 
   447 
   451         Ok(())
   448         Ok(())
   452     }
   449     }
   453 
   450 
   474 
   471 
   475     pub fn client_error(&mut self, poll: &Poll, client_id: ClientId) -> io::Result<()> {
   472     pub fn client_error(&mut self, poll: &Poll, client_id: ClientId) -> io::Result<()> {
   476         self.deregister_client(poll, client_id);
   473         self.deregister_client(poll, client_id);
   477         let mut response = handlers::Response::new(client_id);
   474         let mut response = handlers::Response::new(client_id);
   478         handlers::handle_client_loss(&mut self.server, client_id, &mut response);
   475         handlers::handle_client_loss(&mut self.server, client_id, &mut response);
   479         self.flush_server_messages(response);
   476         self.flush_server_messages(response, poll);
   480 
   477 
   481         Ok(())
   478         Ok(())
   482     }
   479     }
   483 
   480 
   484     pub fn has_pending_operations(&self) -> bool {
   481     pub fn has_pending_operations(&self) -> bool {