elseware/src/login/main.rs

mod login;
mod character;
mod models;

use std::net::{SocketAddr, Ipv4Addr};
use std::net;
use std::thread;
use std::env;

use mio::tcp::TcpListener;
use mio::{Events, Poll, Token, Ready, PollOpt};
use dotenv::dotenv;

use diesel::r2d2;
use diesel::prelude::*;
use diesel::pg::PgConnection;

use models::{NewUser, UserAccount};

fn main() {
    dotenv().ok();

    //let database_url = env::var("DATABASE_URL").unwrap();
    //let conn = PgConnection::establish(&database_url).unwrap();

    //use elseware::schema::user_accounts::dsl::*;
    //use elseware::schema::user_accounts::table;

    /*let u = NewUser::new("hi".to_string(), "qwer".to_string());
    diesel::insert_into(user_accounts).values(&u).execute(&conn).unwrap();
    let u = NewUser::new("hi2".to_string(), "qwer".to_string());
    diesel::insert_into(user_accounts).values(&u).execute(&conn).unwrap();*/

    println!("[login+character] starting server");

    let database_url = env::var("DATABASE_URL").unwrap();
    let connection_manager = r2d2::ConnectionManager::<PgConnection>::new(database_url);
    let connection_pool = r2d2::Pool::builder()
        .build(connection_manager).unwrap();

    let login_listener = TcpListener::bind(&SocketAddr::from((Ipv4Addr::new(0,0,0,0), login::LOGIN_PORT))).unwrap();
    let character_listener = TcpListener::bind(&SocketAddr::from((Ipv4Addr::new(0,0,0,0), character::CHARACTER_PORT))).unwrap();

    let login_shared_state = login::SharedLoginState::new(connection_pool);

    let poll = Poll::new().unwrap();
    poll.register(&login_listener, Token(0), Ready::readable(), PollOpt::edge()).unwrap();
    poll.register(&character_listener, Token(1), Ready::readable(), PollOpt::edge()).unwrap();

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

    loop {
        poll.poll(&mut events, None).unwrap();

        for event in &events {
            match event.token() {
                Token(0) => {
                    login_listener.accept().map(|(socket, addr)| {
                        let shared_state_clone = login_shared_state.clone();
                        thread::spawn(move || {
                            println!("[login] accepted connection: {}", addr);
                            login::new_client(socket, shared_state_clone);
                        });
                    });
                },
                Token(1) => {
                    character_listener.accept().map(|(socket, addr)| {
                        let shared_state_clone = login_shared_state.clone();
                        thread::spawn(move || {
                            println!("[character] accepted connection: {}", addr);
                            character::new_client(socket, shared_state_clone);
                        });
                    });
                },
                _ => {}
            }
        }
    }
}