beteran-api-kgon-server-service/src/main.rs

//!
//!
#[macro_use]
extern crate diesel;
#[macro_use]
extern crate diesel_migrations;

use diesel::{
  r2d2::{ConnectionManager, Pool},
  PgConnection,
};
use std::env;

mod api;
mod compositions;
mod core;
mod events;
mod repositories;
mod schedulers;
mod services;
mod synchronizations;

diesel_migrations::embed_migrations!();

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
  let url_db = match env::var_os("URL_DATABASE") {
    Some(v) => v.into_string().unwrap(),
    None => "".to_string(),
  };

  let url_broker = match env::var_os("URL_BROKER") {
    Some(v) => v.into_string().unwrap(),
    None => "".to_string(),
  };
  let queue_broker = match env::var_os("QUEUE_BROKER") {
    Some(v) => v.into_string().unwrap(),
    None => "".to_string(),
  };

  let k_url = match env::var_os("K_URL") {
    Some(v) => v.into_string().unwrap(),
    None => "".to_string(),
  };
  let k_username = match env::var_os("K_USERNAME") {
    Some(v) => v.into_string().unwrap(),
    None => "".to_string(),
  };
  let k_secret = match env::var_os("K_SECRET") {
    Some(v) => v.into_string().unwrap(),
    None => "".to_string(),
  };

  let api_config = core::config::ApiConfig {
    k_url,
    k_username,
    k_secret,
  };

  let manager = ConnectionManager::<PgConnection>::new(url_db);
  let pool = Pool::builder()
    .max_size(10)
    .test_on_check_out(true)
    .build(manager)?;
  let conn = pool.get()?;

  embedded_migrations::run(&conn)?;

  let broker_opts = nats::asynk::Options::new();
  let connection_broker = broker_opts.connect(url_broker).await?;

  let vendor_synchronizer =
    synchronizations::vendor::synchronizer::Synchronizer::new(pool.clone(), api_config.clone());
  let game_synchronizer =
    synchronizations::game::synchronizer::Synchronizer::new(pool.clone(), api_config.clone());
  let member_synchronizer = synchronizations::member::synchronizer::Synchronizer::new(
    connection_broker.clone(),
    pool.clone(),
    api_config.clone(),
  );
  let member_account_synchronizer =
    synchronizations::member_account::synchronizer::Synchronizer::new(
      connection_broker.clone(),
      pool.clone(),
      api_config.clone(),
    );
  let betting_history_synchronizer =
    synchronizations::betting_history::synchronizer::Synchronizer::new(
      pool.clone(),
      api_config.clone(),
    );

  let vendor_service = services::vendor::service::Service::new(
    connection_broker.clone(),
    queue_broker.clone(),
    pool.clone(),
  );
  let game_service = services::game::service::Service::new(
    connection_broker.clone(),
    queue_broker.clone(),
    pool.clone(),
    api_config.clone(),
  );
  let member_service =
    services::member::service::Service::new(connection_broker.clone(), queue_broker.clone());
  let member_account_service = services::member_account::service::Service::new(
    connection_broker.clone(),
    queue_broker.clone(),
  );
  let betting_service = services::betting::service::Service::new(
    connection_broker.clone(),
    queue_broker.clone(),
    pool.clone(),
  );

  let member_event_handler = events::member::event::EventHandler::new(
    connection_broker.clone(),
    queue_broker.clone(),
    pool.clone(),
    api_config.clone(),
  );
  let member_bank_deposit_event_handler = events::member_bank_deposit::event::EventHandler::new(
    connection_broker.clone(),
    queue_broker.clone(),
    pool.clone(),
    member_account_synchronizer.clone(),
    api_config.clone(),
  );
  let member_bank_withdraw_event_handler = events::member_bank_withdraw::event::EventHandler::new(
    connection_broker.clone(),
    queue_broker.clone(),
    pool.clone(),
    member_account_synchronizer.clone(),
    api_config.clone(),
  );

  let mut sched = tokio_cron_scheduler::JobScheduler::new().await?;

  let game_scheduler = schedulers::game::scheduler::Scheduler::get_instance(
    sched.clone(),
    vendor_synchronizer.clone(),
    game_synchronizer.clone(),
  )?;
  game_scheduler.queue().await?;

  let member_scheduler = schedulers::member::scheduler::Scheduler::get_instance(
    sched.clone(),
    member_synchronizer.clone(),
  )?;
  member_scheduler.queue().await?;

  let balance_scheduler = schedulers::balance::scheduler::Scheduler::get_instance(
    sched.clone(),
    member_account_synchronizer.clone(),
  )?;
  balance_scheduler.queue().await?;

  let betting_history_scheduler = schedulers::betting_history::scheduler::Scheduler::get_instance(
    sched.clone(),
    betting_history_synchronizer.clone(),
  )?;
  betting_history_scheduler.queue().await?;

  let _h_scheduler = sched.start().await?;

  println!("Server service [beteran-api-kgon-server-service] is started");

  futures::try_join!(
    vendor_service.subscribe(),
    game_service.subscribe(),
    betting_service.subscribe(),
    // member_service.subscribe(),
    // member_account_service.subscribe(),
    // betting_service.subscribe(),
    member_event_handler.subscribe(),
    member_bank_deposit_event_handler.subscribe(),
    member_bank_withdraw_event_handler.subscribe(),
  )?;

  sched.shutdown().await?;

  Ok(())
}