1 #![allow(unused_imports)]

     2 #![deny(bare_trait_objects)]

     3 

     4 //use std::io::*;

     5 //use rand::Rng;

     6 //use std::cmp::Ordering;

     7 use mio::net::*;

     8 use mio::*;

     9 use log::*;

    10 

    11 mod utils;

    12 mod server;

    13 mod protocol;

    14 

    15 use crate::server::network::NetworkLayer;

    16 use std::time::Duration;

    17 

    18 fn main() {

    19     env_logger::init();

    20 

    21     info!("Hedgewars game server, protocol {}", utils::PROTOCOL_VERSION);

    22 

    23     let address = "0.0.0.0:46631".parse().unwrap();

    24     let listener = TcpListener::bind(&address).unwrap();

    25 

    26     let poll = Poll::new().unwrap();

    27     let mut hw_network = NetworkLayer::new(listener, 1024, 512);

    28     hw_network.register_server(&poll).unwrap();

    29 

    30     let mut events = Events::with_capacity(1024);

    31 

    32     loop {

    33         let timeout = if hw_network.has_pending_operations() {

    34             Some(Duration::from_millis(1))

    35         } else {

    36             None

    37         };

    38         poll.poll(&mut events, timeout).unwrap();

    39 

    40         for event in events.iter() {

    41             if event.readiness() & Ready::readable() == Ready::readable() {

    42                 match event.token() {

    43                     utils::SERVER => hw_network.accept_client(&poll).unwrap(),

    44                     Token(tok) => hw_network.client_readable(&poll, tok).unwrap(),

    45                 }

    46             }

    47             if event.readiness() & Ready::writable() == Ready::writable() {

    48                 match event.token() {

    49                     utils::SERVER => unreachable!(),

    50                     Token(tok) => hw_network.client_writable(&poll, tok).unwrap(),

    51                 }

    52             }

    53 //            if event.kind().is_hup() || event.kind().is_error() {

    54 //                match event.token() {

    55 //                    utils::SERVER => unreachable!(),

    56 //                    Token(tok) => server.client_error(&poll, tok).unwrap(),

    57 //                }

    58 //            }

    59         }

    60         hw_network.on_idle(&poll).unwrap();

    61     }

    62 }